This project has been deleted.
June 20, 2025
Added a randomizer utility using which the ball can bounce off at random, making the OutBreak sample game more entertaining.
Brightened the background of WASM builds' unsupported system error page.
Added filename hashing for WASM builds, avoiding browser and Cloudflare cache on new build releases.
Made GitHub actions and Docker builds use this advantage.
Updated README and configuration for easier, more predictable and cleaner building approach.
Made Hack Club have its own provider for all models, since it uses the same schema for all sub-providers.
Removed model field from Hack Club as model selection is handled on their server's side.
Made model be empty by default and mandatory by the user to be set for Google and OpenAI providers.
Added better documentation on this in README and config files and fixed some subtle bugs.
cool :) devlog more for better votes :)
Made the last step from developing side pre-ship - implemented GH actions workflow!
Now anyone can download the latest image only having docker-compose.yml and .env files locally - everything else will be handled by the Docker daemon (unless you want to build yourself, of course).
I might also add a GH release for easy downloadability of this plugin standalone. See you soon, with a ship next time!
Finally fixed all leftover issues:
- Added quota configuring for better responses.
- Added correct JSON parsing.
- Fixed AI provider registration.
- Added a more comprehensive README.
- Fixed Docker and other configs.
- Refactored subtly.
Things left to do:
- GH actions for container build/push to GHCR.
- Logo creation.
- Shipping!!!
Nothing more for now, stay tuned for further updates!
Implemented the first working prototype!
What works:
- Sending chats to AI;
- Getting responses;
- Checking what players exist and targetting only these players for the AI to respond.
What doesn't work:
- System prompts;
- Nicer text formatting;
- Auto detection of inherited AI provider classes (will implement, if that's possible in Java).
Nothing much for the first ship, but after getting now-missing things done it will be mostly ready for a minor release.
Added simple prevention of mobile usage of built WASM games as the engine is not yet compatible with mobile games, just as the demo.
The demo can be played on desktop browsers using arrow keys. More at outbreak.domax.lt
Also added credits for the ball asset.
Crimson Demo is finally released! To check out all of its capabilities, read the README.md and try creating a game yourself! ;D
Implemented game centering to OutBreak, removed Crimson demo game I used for testing and added Docker build support so I can easily host the WASM demo game!
Added a texture for the ball.
Made a GitHub action for OutBreak's Docker build.
Updated the README so it's more clear on what to do with this engine.
Fixed scripts so they work as expected too. Crimson is finally a full-on game engine ready to be developed with!
Finally added a demo game - OutBreak!
Fixed MANY issues with collisions:
- Too agressive transform and collision component integration with each other ended up often blocking initalization.
- Redefined API, and now game dev chooses when to block and when to not using transform component manually. Collision component provides only calculations.
- Implemented more features to the collision system, like normal and hit point vector calculations which help when developing something like OutBreak - where accurate normals can be used to calculate how to bounce off of objects.
- Made map collision tiles be lightweight entities for easier collision integration and later manipulation.
Also made multi-game builds possible:
For WASM:
- Each game has its own sandboxed subdirectory under build-wasm/bin/{config}/{game} with index.* files ready to be hosted.
- Each game links everything in statically and is meant to be hosted separately.
For native builds:
- One unified launcher, built with a game selector (with the help of wxWidgets) lives under build-native/bin/{config}.
- Each game is under build-native/bin/{config}/games/{game}, where its DLL and data are stored.
- The game launcher knows which games are valid based on game's Manifest presence under config/Manifest.json.
- When launching the launcher, it lets user select which of available games to play. This was done to avoid having a hardcoded game target into the launcher, adding the ability to mod and freely create many games using Crimson.
Removed a LOT of legacy code, introduced more utils and components to cope together with OutBreak and more games in the future.
Crimson is really close to its first ship. Remaining things post-ship are:
- Tweaks to the OutBreak demo (visual and game loop upgrades that make the game more exciting) (might do this pre-ship and sip the OutBreak game with tweaks already made for an exciting gameplay experience).
- Docs and UI systems (this engine lacks these still).
- Nothing more? Maybe bug and convenience issue fixes (if any are present).
Finally - a good entity and map collision system, taking advantage of LDTk's (map editor's) intGrid feature and existing ECS.
Made it customizable with future-proof structure and architecture, for further implementations from me and other devs.
Implemented easy to understand development cycle - components do their job alone, game devs not having to DIY the built-in systems (unless they want something extra).
Updated entity systems as well - added initialization to components on addition and made entity scripting in their own files possible, instead of implementing them in a level script - fixed scene lifecycle, which prevented such things.
Next steps:
- Demo game for a ship (I'm thinking about an Atari Breakout clone).
- Docs.
- UI system (maybe?).
- Nothing else, at least for SoM I have planned, regarding Crimson. Maybe more simple demos (like Flappy bird or Space Invaders clones, remade purely in Crimson). Most likely I'll just start a new project and leave Crimson for people to use, maybe use it in a game jam.
Made some real fancy advancements since the last devlog:
An entity component system.
Subtle refactoring and clearer API for game developers.
A better and fixed way of creating new games - now Crimson comes with a sample game generation script, which is the best way to start.
It's starting to become more and more like a game engine ready for games, than a DIY project.
Best thing is, with the new ECS it will be easier for me to implement a collision system and complete a few web demos.
Next steps:
- Collisions (of course).
- Docs (similar to EchoTuner's).
- None, unless someone who actually ends up using Crimson for their games begs for extra features, like particle and lighting systems, or even a working sound system (hasn't been tested yet).
The engine now supports dual-configuration builds. Current testing went smoothly, without much issues or bugs.
After about a month of forgetting this project and focuding on EchoTuner, I have finally decided to get back - and with good news!
WASM support is fully implemented! A bit sloppy, but not for long.
Crimson engine now supports standalone windows and linux builds, as well as WASM web builds, making it very easy for me to ship a demo!
Wish me luck and wait for the full release!
Docs are finally working!
Anyone can now access API docs at echotuner-docs.domax.lt
With the app working as expected, with better limit system and other tweaks, anyone can use it with no problems whatsoever, with only a handful problems left to solve - EchoTuner is ready for its third ship!
Added professional API docs!!!
Now every developer can look up how to use EchoTuner's API (provided they host the docker image themselves and have an account on EchoTuner (given more time, I'll implement a web console and API keys). I'm still working on both updating, reviewing the docs and hosting them (should be done tomorrow), since for time saving purposes I have used AI to generate it just for the docs to be there. Many reviews await, as well as app's docs!)
By my decision, I won't be spending much time on updating the app's code and structure as it takes really long time to do so, and AI isn't helping much. Seeing this as a low priority job (at least for now), it may be done sometime in the future. Currently, the app works and I'll be focusing on updating the docs, probably working on more QoL improvements and shipping both this project and my other project - Crimson with WASM support coming (stay tuned!! (Pun not intended, even though it sounds funny - EchoTuner and stay tuned)).
Started working on restructuring the app to use domain-driven development patterns. Also started planning on how docs are going to be made (current solution - a Jekyll-built webpage for easy docs' changes using markdown).
The app needs a lot of testing to make sure everything works as it did without major changes in functionality, since API isn't going to be changed too much over the course of following week. Another priority - ensuring the app looks pretty much the same besides feeling like a completely different project when looking at its codebase.
I really hope I can pull these advancements off and make the app not only work well, but also be nice to code by getting rid of its monolithic design.
After a long break from coding, I'm back at it again and got some nice QoL updates for EchoTuner:
App now limits input fields so that user doesn't have to stare at an error pop up when input prompts are too long (since limits can now be seen in the app, it adds clarity).
Fixed asynchronous login bug, where the login button acted as a popup - first gathering info about itself from the API (OAuth login link) and only then performing an action - Safari and WebView systems don't like such behaviour and often end up blocking it. Havent tested it fully, but conceptually it should work.
Made so that fewer API calls are being done resulting in less abuse and lighter systems.
Further plans:
- Nice documentation.
- Nice app structure tat mimics API's.
- API refactor with more clarity.
- API keys for external usage.
EchoTuner has finally reached its second beta release! With all the promises done and ready to experience, it's more convenient than ever before! With improved account handling and cross-device support for shared mode users (normal mode hasn't been tested yet, but I'm making huge progress in doing so - making developer-focused updates, which include better documentation, structure and moddability), you can use it at full capability. Even the limits have been increased, since I'm able to provide users with a bit more than initially thought I could (5 daily playlists is better than 3!)
Can't wait for you all to try it out!
EchoTuner is getting really close to its second beta release! With full support for cross-device compatibility in both shared AND normal modes, slight UI tweaks, full implementation of Coming Soon features in the app and a massive refactor in how the full-stack app is structured, can be used (API usage will depend on proper REST principles from now on) and how the database looks like, this is nothing but a dream for both users and developers wanting to explore EchoTuner and using it free of charge.
Even though EchoTuner has been shipped, work on it continues. I've got big plans for an upcoming Google SSO login feature so that even demo mode users can enjoy cross-device, free of charge! I've got a lot of work to do and will probably spend a quite a lot of time on this alone, as well as a massive refactor for both the API and the app to use a domain-driven approach of structure and architecture. But I really hope that by the end of this month everyone will be able to use the updated, secure and advanced implementation of EchoTuner with hardly any limitations noticable!
After spending almost 130h, fixing countless bugs, facing issues and having to bypass things that don't depend on me, I've come to the conclusion that Spotify is one of the least friendly platforms for developers.
They've got the worst support I've come across. Despite having ready-to-use OAuth clients, making such critical changes to usage policy this late is really awful on their part. For anyone reading this having similar ideas, either don't start or prepare for many inconveniences.
However, EchoTuner won't stop there! By implementing a feature where all the Spotify queries between API and their servers happen using only the OAuth client owner's access token, I made sure the whole full-stack app works fine and is ready for deployment. With only a handful of things missing (and a massive refactor needed) EchoTuner will most likely be available to use sooner than 24h after publishing this devlog.
I'm very glad how the journey turned out. I've learned a lot (and could note many places for improvements), and couldn't be happier. It's true that I'm very irritated about Spotify almost leading me to give up and preventing this whole idea from becoming true, but who am I to put this project down? EchoTuner will continue until anyone can experience it, with many improvements to come!
Today has marked a lot of time wasted on useless improvements that had a chance of working but lead to me failing to refactor the whole codebase 2 times with significant API and logic changes and overengineering on working things, after which I kind of gave up on these major changes and decided to take everything slow. The current container builds work, but the codebase is a mess. Looking forward to improving it with dedicated routing, cutting down main.py size in half and structurizing database operations better.
I'm deciding on whether or not to remove the refinement feature, since the refinements are inaccurate for the most part and hard to manage in code, but I haven't decided on that yet. Tomorrow I will.
Today wasn't the most successful day, but lead to having 7 additional hours appended to this project, which, in my mind, is quite good.
Since the server machine is still having issues from being able to launch my API and web app, I'm continuing work on the API, implementing further architectural changes, such as migration to ORM, embedding caching and so on.
It's very sad that launch has been delayed so many times, but I'm not giving up, even after so many roadblocks EchoTuner has faced. It must be launched, but now it just depends on time. If I'm lucky, this month's the charm. If not, I hope that summer will let me make a functional demo for the whole community and beyond test out, providing suggestions on further improvements.
For the next few hours of coding, I will be focusing on improving both the app and the API to be more enterprise-like, with no place for human error (I'm looking at you, hardcoded database queries!) and/or vulnerabilities. Wish me luck!
Implemented better CORS handling.
Implemented better validation for prompts, errors, etc.
Fixed API stalling issue, where an asynchronous task was being run incorrectly (playlist draft service).
Implemented IP rate limiting.
Made Uvicorn exclude, rather than include manual reload directories for easier management.
Subtle formatting changes.
Incremented version minor number.
Made some bugfixes for EchoTuner.
Finally resolved database sharing question - now, by default, it's saved in storage/echotuner.db and by taking docker-compose.yml sample file from EchoTuner's GitHub you can easily check out how mounted storage works, having the ability to share your database across different containers and not having to worry about container deletion - database will be preserved in system files!
Switched to envsubst, providing a template of javascript file that holds environment values for web app, passing required variables through the environment instead of hardcoding them into the entrypoint shell script.
Implemented GitHub Actions and published containers onto the GitHub Container Registry for anyone to use!
And fixed a bug with GitHub actions where the Flutter web app couldn't get any environment variables without a provided file (that bakes the variables into the app). Now it supports environment through an external javascript file that gets updated with the latest variables everytime you run the container, not even needing to include a .env file in the pubspec.yaml anymore! It's considered some subtle hacking-around the Flutter's system (since it builds static content) and requires a deprecated library as fully supported alternatives don't exist yet. But it finally works and is ready for deployment!
Made a lot of changed over the past few hours:
- Fixed Docker composing.
- Implemented security features (body-based request philosophy, better prompt validator).
- Updated endpoint naming scheme.
- Implemented docs.
- Implemented better cleanup logic.
- Refactored written code.
- Changed logging to debug for unnecessary log protection.
- Updated Flutter packages' versions.
And probably more I don't even remember. This project is ready for production and demo release, I just have to get a way to host the ecosystem. Since it's done through Docker containers, in case you wanted to try it out early and without limitations, you can do so by visiting the Github repository of Echotuner and following quick startup guides for an easy setup (Github container registry entry coming soon for an even easier deployment). Don't mind Dart errors - they're there just because JSON serializable code hasn't been generated yet, which will be fixed during the Docker container build.
Moved all api endpoint methods to separate files in api/endpoints/.
Began making modular AI model setup.
Next steps (since AI models implementation took a bit of a turn):
- Finish refactoring the API and the app (their code).
- Finish implementing the modularity of the api providers.
- Refactor the API endpoints.
- Release the app (due to recent roadblocks of Spotify API usage and other implementation bugs it's been delayed a bit. Expecting to release the demo in 1-3 days).
- Make better docs.
Started working on demo account creation and app handling of them for the release.
Due to Spotify's new OAuth client policies, an app like this will never be able to be launched in full scale, as described here:
https://developer.spotify.com/documentation/web-api/concepts/quota-modes
But that didn't let me down as I will be implementing a new demo-mode for users to experience and and provide tools for them to run the app themselves under their administration if they wish to use it without limits and using their OAuth clients.
Don't know what pushed Spotify into disrupting the creation of such services by pulling the plug on personal quota updates on OAuth clients, but I won't let such roadblock stop me from maintaining this project!
Implemented a better integration with more AI providers other than Ollama.
Added a singleton pattern for services which are responsible for themselves
Made more services each doing their own thing.
Made a lot of security improvements (restriction of certain endpoints and more).
Implemented reusable templates, systems and services for the app.
Made a custom logger more useful/usable.
Reworked the UI and UX a bit.
Made improvements to app's stability when dealing with personality and playlist adjustments (lauto-saving, auto-reload, deletion and editing of playlist as soon as it gets generated and more).
Updated READMEs to reflect the app better.
Next steps:
- Docker image build support
- Login security enhancements
- Hosting
- Publishing
Implemented the ability to use more models and providers, not only Ollama ones.
Added silent refresh in personality screen, library is still waiting for such an upgrade.
I'm yet to check if everything works, but tomorrow will be the day I get to do so and (hopefully) have the first, fully working release version of this project! Very excited for it
Only minor UI refreshments remain and maybe some code restructuring for it to look nicer (I don't like the idea of files being 1000+ lines of code long, especially in such a simple project).
And on the backend side of things, tests must be made to ensure everything is secure, convenient and usable with no weird errors occuring. It's going to be a long day or two!
Implemented a personality edit service with a slight tweak of how UI works and feels.
Also added some branding in the login screen, as well as an icon for the EchoTuner app.
Known issues:
- Some UI elements aren't appealing or functional.
- Screens don't refresh at times.
- A lot of leftover/garbage/ugly code.
- Lack of documentation with the latest changes.
- Security issues as the latest version is debug-oriented.
- AI isn't trained properly yet.
Aside from these issues this service is completely functional and you can start using it locally with an official demo coming soon!
Finally! The app (and the API) is ready for production!
I have addressed the issues they both had and fixed them leaving only the app with a minor design flaw on PC builds (info messages are too high up as they've been adjusted for phones and haven't seen a platform-independent way of handling this) and a READMEs update with the latest changes of this project.
The app works just as you would expect with only one core feature missing (personality adjustments) (other working things are yet to document).
After implementing it and fixing the design flaw mentioned above, I'll move onto hosting this for you to experience!
Added the ability to add generated playlists to Spotify and refine existing ones.
Known issues:
- Refinements seem infinite after a playlist has been added to Spotify. It should be known to the API how many times has a user refined generated playlists before addition and that number should stay the same across the refresh window.
- No option to update existing playlists. A user can only add a new one from the old one's refinement.
- Information messages don't look good and aren't of one design.
- Refreshing the Spotify playlists menu brings a user back to the drafts.
- Drafts are stored on device, but they should be stored per-account in the server with a deletion span until they've been added to Spotify.
Next step would be to resolve these issues and enhance/check the security of this implementation as the latest changes were done very fast with little to no refines of the code.
Removed WebView dependencies and moved everything to a default device browser for OAuth handling.
Updated the design.
Implemented server-side UUID v4 authentication to prevent spoofing.
Improved rate limiting and added indications for it in app as well as device recognition improvements.
Removed leftover API code related to the database and device verification.
Added auto registration and prevention of re-registration.
What's next:
- Addition of the playlist to user's Spotify account.
- Implementation of buttons that are yet to implement.
- Hosting and demo.
- Submission.
Implemented the Spotify OAuth login.
Everything works as expected, with a browser launching as soon as you click on the login button and guiding you through the login process. After logging in and returning to the app you can use all its functionality.
What's left to introduce:
- Better documentation (obviously)
- Structural changes
- Mobile app testing (since I haven't had a chance to set up mDNS on my PC)
Changed the interface and improved user experience in the EchoTuner Flutter app:
- The color scheme now features violet as the main color.
- The app has a sticky footer that's yet to fully implement.
Also added more directives to developers on setting the app up and testing it.
Further changes include Spotify logins and app funcionality improvements.
Made a very basic app, now the API can be interacted with from somewhere else, rather than making Postman requests.
Known bugs:
- [pc-name].local:[port] doesn't work on other devices.
- Setup files don't work.
I'll begin working on a redesign of the app, bugfixes and Spotify credentials' auth, as well as futher API tweaks so the integration is better with the ecosystem.
In a few days I'll try to host a web demo of this service too!
Finally implemented quite a big database of songs, artists and other preferences to pass onto the AI models to help with their tasks.
Upgraded performace MASSIVELY by running async operations instead of dealing with them one-by-one.
Next step for the API would probably be to load training data for the models directly instead of passing everything as context parsed from JSON files.
Also, an app is on its way! I can't wait to finish it!
Reworked how logs are generated, now it looks better and provides more accurate information. Tried to match the logs to how Uvicorn server is printing them out.
Still a bug when checking the Spotify search availability occurs stating it's in fallback mode (but isn't), working on a solution for it.
Improved text recognition calculation slightly, but it still needs way more patterns. They'll probably be in a database or a JSON file to avoid hardcoding data into scripts and improve mobility of the API to be available with different data sheets.
Just implemented the first version of the API!
Right now it has:
- Playlist generation (and refinement):
- Integrates with local Ollama models
- Verifies if the request is valid (still clunky, needs more context)
- Searches songs on Spotify and returns a list in JSON format
- API health checkups
- Rate limiting (needs more work and testing)
Next steps:
- Implement an app (that will handle addition of the songs to user's Spotify account and interaction with the API)
- Update the context for the songs looked up and the prompts validated to be more accurate to what the user wants
EchoTuner is a tool for generating your personalized Spotify playlists based on audio features like energy, valence, danceability, and more. It started off as a fun idea for a simple public-facing app, but quickly ran into the modern reality of building with Spotify's Web API. Although many roadblocks have been faced throughout this project's creation, EchoTuner has managed to hold on and turn into a great service anyone can use. EchoTuner utilizes modern AI generation to make the best playlist just for you and delivers it straight to a Spotify account to be claimed.
Implemented a new way to add a player to the scene! (Or any other entity, really)
Instead of having to manually set the position of an entity, now everything's possible through the same level editor used to edit levels!
Crimson's going to shift towards adding sounds, collisions and UI systems for better developer experience. After that, Crimson's game building itself awaits!
A simple and powerful 2D game engine designed for learning game development fundamentals. Built with modern C++ and focused on providing an easy-to-understand API that doesn't hide the underlying architecture. Crimson's focus - simplicity and learning game development at a lower level with an intuitive API. Crimson's purpose - passion to understand low-level game engine architecture myself, and to provide an open library for the community, requiring no licensing fees and providing true cross-platform compatibility for simple 2D game development.
This was widely regarded as a great move by everyone.