Algora
By
@diputs
- 17 Devlogs
- 30 Total hours
An attempt to put everything I wish I had when learning algorithms into one place.
algora dev log #8
Spent some time building the Insertion Sort page today! Added the frontend and TypeScript, then finished implementations in C, C++, Java, and Python.
Next up: Intro Sort!
#Algora dev Log #3
Today’s goal was simple:
Get Bitonic Sort fully working from end to end.
Turns out that meant building a lot more than just Bitonic Sort.
The day started with finishing the Bitonic Sort page itself.
The visualizer, controls, explanations, pseudocode section, code viewer, and all the usual algorithm page stuff are now in place.
At this point the page finally feels like a real part of the site instead of a placeholder.
Most of the work ended up happening behind the scenes.
I spent a good chunk of time building out the animation system that powers the visualizer.
The goal was to make algorithms describe what they’re doing (compare, swap, finished, etc.) and let the frontend handle the actual animation.
It took a bit of trial and error, but the system is finally working and feels flexible enough to support future algorithms.
I also ended up writing way more TypeScript than expected.
What started as “I just need Bitonic Sort working” somehow turned into multiple files handling animation control, code loading, documentation parsing, syntax highlighting, copy-to-clipboard functionality, and a bunch of other supporting systems.
After that came the real test: implementing Bitonic Sort in all four supported languages.
- Python
- C++
- Java
- C
The actual algorithm wasn’t the hard part.
The important part was making sure everything worked together and that the platform could properly support multiple language implementations for the same algorithm.
Thankfully, it worked.
By the end of the day I had:
- Finished the Bitonic Sort page
- Finished the animation engine
- Added playback controls
- Built the code loading system
- Added documentation parsing
- Implemented Bitonic Sort in C, C++, Python, and Java
- Connected everything together
The biggest win isn’t really Bitonic Sort itself.
The biggest win is that the system now works.
Future sorting algorithms should be significantly easier to add because most of the annoying infrastructure work is finally out of the way.
Current Status
- Bitonic Sort page complete
- Animation system working
- Multi-language code viewer working
- Bitonic Sort implemented in C, C++, Python, and Java
- First sorting algorithm fully integrated into Algora
Next up: more algorithms !!
Algora dev log #2!
Spent another session focused on building the Sorting Algorithm Index for Algora.
The goal was to create a dedicated hub where users can browse algorithms, compare characteristics, and quickly find the right visualization to explore. Most of the work went into designing the overall layout, building algorithm cards, organizing metadata, and creating filtering and discovery systems.
A large portion of the work has gone into creating the Sorting Algorithm Index, a central hub where users can browse, discover, and eventually compare different sorting algorithms. Most of this process involved designing and implementing the interface using HTML and CSS, with a focus on creating a clean layout that can scale as more algorithms and features are added.
The page now includes searchable algorithm cards, filtering options, learning path recommendations, and categorized algorithm metadata to help users quickly find relevant topics. While the visual design makes up the majority of the implementation, a small amount of TypeScript has also been introduced to support interactive features such as search and filtering.
Progress
- Continued work on the Algora frontend
- Improved the landing page and overall UI
- Fixed various styling and layout issues
- Continued polishing the user experience
Next Steps
- Implement Python versions of all sorting algorithms
- Implement C++ versions of all sorting algorithms
- Implement Java versions of all sorting algorithms
- Implement C versions of all sorting algorithms
- Connect code implementations to algorithm pages
- Continue work on visualization and comparison tools
Planned Sorting Algorithms
- Bitonic Sort
- Bubble Sort
- Bucket Sort
- Counting Sort
- Heap Sort
- Insertion Sort
- Intro Sort
- Merge Sort
- Merge Sort (In Place)
- Quick Sort
- Radix Sort
- Selection Sort
- Shell Sort
- Tim Sort
- Tournament Sort
Working on Algora
Spent most of today working on the frontend for Algora, a project I’m building to help learn algorithms through interactive visualizations and comparisons.
A lot of my time went into building the main landing page and polishing the overall look of the site. Surprisingly, the hardest part wasn’t the algorithms themselves which ofc it was CSS. I ended up spending way longer than expected trying to get layouts, spacing, responsiveness, and animations to behave the way I wanted. At this point my wrist is probably filing complaints against me.
Not everything is working yet either. Some parts of the site are still unfinished, and a few features (including parts of the preview and visualization system) are still being actively worked on. There were definitely a lot of moments where something looked fine in my head and then completely broke the second I opened it in the browser.
Even though progress felt slower than I expected, it’s starting to come together. The homepage is beginning to feel like something real instead of a collection of random components, and the overall direction of the project is becoming much clearer.
Today’s Progress
- Continued building the Algora frontend
- Worked on the main landing page
- Improved layout and styling across multiple sections
- Fixed various UI issues
- Continued work on algorithm visualizations
- Recorded a development timelapse
Still a long way to go, but seeing everything slowly come together has been pretty motivating.