1,681 karma · joined January 2, 2022
I mean even patent has 20-year limit
The syntax is hardware-inspired, wysiwyg-style lazy diff graph updating. you can use it directly through wasm on the web page; there is also a cross-platform cli version:
https://github.com/glicol/glicol-cli
I am currently working on porting it to no std embedded systems
I once made a very raw chrome plugin to sample any webpage; I guess it's still functional:
Btw does anyone know if there are any larger, mass-producible micromotors on the market that can be used to make products similar to the smartknob?
it's ported from Rust
For a long time, the common practice in live coding, which you might see on platforms like Flok.cc (https://flok.cc) supporting various interesting languages, has been like this: Everyone gets their own 'space' or editor. From there, they send messages to a central audio server to control their own sound synthesis.
This is heavily influenced by architectures like SuperCollider's client-server model, where the server is seen as a neutral entity.
Crucially, this relies a lot on social rules, not system guarantees. You could technically control someone else's track, or even mute everything. People generally restrain themselves.
A downside is that one person's error can sometimes crash the entire server for everyone.
Later, while developing my own live coding language, Glicol (https://glicol.org), I started exploring a different approach, beginning with a very naive version: I implemented a shared editor, much like Google Docs. Everyone types in the same space, and what you see is (ideally) what you hear, a direct code-to-sound mapping.
The problems with this naive system were significant. You couldn't even reliably re-run the code, because you couldn't guarantee if a teammate was halfway through typing 0.1 (maybe they only typed 0.) or had only typed part of a keyword.
So, I improved the Glicol system: We still use a shared interface for coding, but there's a kind of consensus mechanism. When you press Cmd+Enter (or equivalent), the code doesn't execute instantly. Instead, it's like raising your hand – it signals "I'm ready". The code only updates after everyone involved has signaled they are ready. This gives the last person to signal 'ready' a bit more responsibility to ensure the musical code change makes sense.
I'm just sharing these experiences from the music-making side, without judgment on which approach is better.
https://github.com/chaosprint/glicol
https://github.com/chaosprint/asak
For LLM, even the latest Gemini 2.5 Pro and Claude 3.7 Thinking, it is difficult to give a code that can be compiled at once.
I think the main challenges are:
1. Their training material is relatively lagging. Most Rust projects are not 1.0, and the API is constantly changing, which is also the source of most compilation errors.
2. Trying to do too much at one time increases the probability of errors.
3. The agent does not follow human's work habits very well, go to docs.rs to read the latest documents and look at examples. After making mistakes, search for network resources such as GitHub.
Maybe this is where cursor rules and mcp can work hard. But at present, it is far behind.
When I was developing Glicol (https://glicol.org/) sync, the main challenge is network jitter. Had to give it up eventually.
Furthermore, have you factored in the synchronization as perceived by the listener?
Also, it seems system-level differences, particularly in audio output latency across various OS and hardware setups, would need to be considered.
What I mean is, the variation in inherent audio output latency between different systems (e.g., Mac vs. Windows, different hardware) could easily exceed 10ms in itself.
https://news.ycombinator.com/item?id=43787012
In my personal opinion, a paradox of truly open-source projects (meaning community projects, not pseudo-open-source from commercial companies) is that development seems to show a tendency of diversity. While this leads to more and more cool things appearing, there always needs to be a balance with sustainable development.
Commercial projects, at least, always have a clear goal: to sell. For this goal, they can hold off on doing really cool things. Or they think about differentiated competition. Perhaps if the purpose is commercial, an editor would be the primary goal (let me know if this is alreay on the roadmap).
---
I don't think the language itself is the problem. The situation where you have to use mature solutions for efficiency is more common in games and apps.
For example, I've seen many people who have had to give up Bevy, Dioxus, and Tauri.
But I believe for servers, audio, CLI tools, and even agent systems, Rust is absolutely my first choice.
I've recently been rewriting Glicol (https://glicol.org) after 2 years. I start from embedded devices, switching to crates like Chumsky, and I feel the ecosystem has improved a lot compared to before.
So I still have 100% confidence in Rust.
i am also working with esp32 s3 but only write rust code
https://youtu.be/y2Hi9ThKcy8?si=yV8onefVb9o7MdHC
My goal is to send midi wirelessly.
I'm curious why you chose the ESP32? Because if you're working offline, the cost for its most well-known features - BLE and WiFi - would be unnecessary.
My current goal is to spend half of my time on the development and maintenance of open source projects, such as Glicol (https://glicol.org/).
The other half of my time is to do some business that can generate profit from day 1.
I just found that the VC model is not suitable for my current situation.
Soon, hiring people for commercial background music might be rare. Think AI for jingles, voiceovers, maybe even the models and visuals. Cafes can use AI-generated music too – in a way, the owner curates or "creates" it based on their taste.
But there are still interesting parts to human music making: the unpredictability and social side of live shows, for example. Maybe future music releases could even be interactive, letting listeners easily tweak tracks? Like this demo: https://glicol.org/demo#ontherun
https://github.com/toplap/awesome-livecoding
also this live coding book is free to read!
However, the aistudio updated today is good.
So it seems that the output is so different because the person in charge is different?
From this perspective, there is no hope for Firebase, because the person in charge has poor management logic. even with the best resources in the world, it doesn't help
https://github.com/wasm-audio/wasm-audio-examples
For workflow, how do you think of async in wit at this moment?
this is a tool I use for Chrome. works for me
you might also be interested in Glicol (https://glicol.org/)
especially this example: https://glicol.org/tour#meta2
it's rhai in rust -> wasm -> sab -> audioworklet