onirom

did a small raw binary-like implementation of an extended (base-16) version : https://www.onirom.fr/wiki/snippets/#JavaScript_:_Extended_C...

doesn't need to be accurate, could do something like this (distance + treshold) :

https://susam.net/fxyt.html#XN128dXN128dpYN128dYN128dpsN4096...

smaller with dup :

https://susam.net/fxyt.html#XN128dDpYN128dDpsN4096lN255pC

circles pattern : https://susam.net/fxyt.html#XDpYDpsN8qN3riN255pC

PS: fun tool !

Somewhat related but this can go pretty low in amount of code (and data) with a bit of design, here is some experiments and details on the generation of monospace blocky font with very low amount of data (data is encoded into bitfield) and how to style it through simple operators or algorithms such as diffusion curves, the aim was slightly different as it focus on using smallest amount of CPU instructions : https://www.onirom.fr/wiki/blog/25-09-2022_tiny_bitfield_bas...

Is there some tools like this which can simulate old school stuff such as magnetic core memory ?

There is Photosounder which have excellent sound quality (all edit is in frequency domain and it then convert back)

For free there is also Virtual ANS and https://www.fsynth.com on the more experimental side (conversion is done raw using additive synthesis, phase information is lost so sound quality is affected)

Are you on Linux ? There is a known issue on Linux with the server running in background when you launch the AppImage directly (by clicking on it) so it is actually launched but you can't see it and if you launch it a second time it will fail to listen because the port is already busy with the first one, the AppImage must be launched in a terminal.

Guess this is not restricted to interface design for example having quit & save keys shortcut close together...

A VSTi i have used several times for birds & animals is "sounds of nature" by Xoxos, maybe you could take a look at how it is done, my guess is some fast FM modulations.

To stay in topic i have synthesized some nature sounds (birds, waters) myself using this synthesizer and a simple two oscillators FM setup with massive pitch modulations for each oscillators, you can hear it on :

https://youtu.be/25o4Ru8kbpE?t=1111

And FM squeaking doors : https://youtu.be/25o4Ru8kbpE?t=1404

So my guess is that some FM with pitch modulation and many oscillators may be the way to go.

Percussion can be synthesized with convincing results through resonant models (simple resonant filters with initial noise), this is called modal synthesis, you can find filters parameters for some real instruments here : http://www.csounds.com/manual/html/MiscModalFreq.html

The sound server itself (the link) is 100% CPU and does not use the GPU at all. One of the client application however (your description) output RGBA data generated by the GPU.

I don't know if that was a good idea considering there is a soldering problem on the Nexus 5X which shorten its lifetime to around 2 years, CPUs just fail after some times. I preferred to take a Android One device since then, cheaper while being similar in speed. (Phones such as Nokia 6.1 and so on) but the Pixel 3a is nonetheless cool, hope it will don't have conception issues!

Built mine some days ago with a custom "portfolio generator" :

https://www.onirom.fr

Yes, this is actually how it work however page flipping mechanism require a memcpy, as such it is as effective as not using page flipping and just memcpy a front buffer to display and doing software flipping through pointers exchange, the only advantage of using page flipping is that it require much less operations and prevent tearing but performance wise, it is roughly the same.

Tried to implement page flipping today and performances are terribly low on the Raspberry PI due to direct draw calls to the video mapped memory... so you need to do a single memcpy to avoid multiple write to the video mapped memory, this result in the initial behavior.

Did a simple clearing test with a 4 cores Raspberry PI 3B and 1280x768 resolution, i get 30 FPS.

However a single core memset (still RPI 3B) for this case is fast : 235 FPS

The time goes into calculating a fullscreen pixels-based effect (so yeah; buffer contents), the point of this library is not the FB implementation which is a simple / bare-metal one.

The point is to render graphics content in a consistent way across multiple CPU cores but still remain lightweight enough to be used with your own implementation, this might change but that was the initial goal.

I am aware of those, this might land in a future update.

The library initial focus was just to get multiple cores to work for graphics task...

A late night mistake that is mostly fixed. (and there are some other typo errors as well, will check it later on)

Thank you!

Released and updated a pixels-based collaborative cross-platform audiovisual live coding environment : https://www.fsynth.com

Nice, remind me of a custom Regex engine i built some years ago in JS while trying to build a fast & small lexer, it does not support ? but +, - and sub-rules, it is around 60 LOC if I remind, mostly built by "accident", it work with JSON as input and output a finite state automaton (compiled version ?)

https://github.com/grz0zrg/jsb/blob/master/lexer.js

Can be useful when you have multiple monitors and don't want to clutter the main window, especially for single page apps or visualization/monitoring things.

I have done my own take at this since some times but vanilla only https://github.com/grz0zrg/wui where any of the dialog widget can be detached off the main window keeping the same content & state. A feature i never saw in any web apps but saw often on desktop apps, nice to see that some peoples think of this sort of thing with cleaner approach!

This is a very interesting way to draw music, lately i have done some experiments with something akin to the Russian ANS synthesizer which was a photoelectronic synthesizer where the sound spectrum was sketched onto glass disks, in my program all is driven by visuals produced by a GPU fragment shader, one can use a webcam as a texture to replicate something akin to the ANS workflow where you draw the sound spectrum although it is much less limited, one could also capture a painting software and feed their drawing in realtime.

The synthesizer is available here : https://www.fsynth.com

https://www.fsynth.com is a web synthesizer which is just doing that, a canvas content is generated by the GPU and converted to sounds in real-time, there will be a feature to import sounds directly soon.

Adding sines is the basis of additive synthesis, you are correct about the ratio, i have made a visual additive synth which is just adding alot of sinewaves (Y axis represent frequencies)

https://www.youtube.com/watch?v=jBg3DnElfHk

The ideas "Cyber-physical programming" around extempore seem interesting!

Livecoded visuals/sounds is something i have been doing with a livecoding tool that i develop where a graphical canvas is actually both, the audio spectrum and the visuals, all driven by a single GLSL fragment shader : https://www.fsynth.com

Owning your data and not letting any third parties its access

Fragment was updated today with a new web audio synthesis engine which allow near perfect audio output on Chrome and related browsers, there is also much improvements for Firefox, i am still working on all the performances issues related to the web audio part of the application so there is many more things to come!

There is also a live logarithmic scale spectrum of the output :) and many other fixes.