Bad Diode

@badd10de.bsky.social

63 Followers 56 Following

Musician and tinkerer. Exploring the interactions of the old with the new. Making and playing with music toys and tools. he/him/they/them My website: https://badd10de.dev STEPPER: A 16 step sequencer for the GBA: https://badd10de.itch.io/stepper-gba

Hermann Gäns playing with a modular synthesizer system. A dark silhouette against a green projected screen. Cables hang in a chaotic way.

A little sample player for the playdate with some oscilloscope and rms/peak meters.

PlayDate console recording a fragment from "Its Ok to cry" by SOPHIE and playing it back.

A PlayDate console showcasing a demo of a sample player playing an amen loop. The screen shows the sample waveform and playhead as it goes.

A graph diagram showing the parse tree of some code where different variables are being declared: A simple Int, a function pointer and a reference to an Int.

A terminal screen showing some code and a playdate simulator with the resulting output.

A PlayDate console on top of a desk, running the game Oquonie

Badlang code with some conditional expression and the linear IR it produces.

badlang code and the symbol table it generates

AST of the self-hosted implementation of a parser and the code that generates it

badlang code and the equivalent AST representation, where multiple nodes are connected with nice looking arrows.

a couple of expressions on a badlang program alongside the AST it generates, visualized with graphviz

badlang code showing a lexer being initialized and attempting to lex itself. The resulting tokens are on the right.

game of life, where alpha trails are displayed instead of cells being just on/off

video showcasing the game of life written in badlang and rendered with raylib

badlang code for rule110 along with its output

choice Result :: T {
Ok: T
Err
}

match Result::(Str).Ok("hello") {
Ok(x) = x
Err = "error!"
}

match Result::(Int).Ok(123) {
Ok(x) = x
Err = 4
}

choice Either :: (A B) {
Left: A
Right: B
}

match Either::(Int S8).Left(123) {
Left(x) = x
Right(y) = y
}

some badlang code and the resulting type table:

struct Single :: T {
x: T
y: Int
}

; let err: Single ; This should fail, polymorphic type is not qualified.
let s0: Single::Int
s0
s0.x
; set s0.x = "hi" ; fails
set s0.x = 10 ; succeeds
let s1: Single::F64
s1
s1.x
set s1.x = 2.0 ; succeeds

struct Tuple :: (L R) {
left: L
right: R
}

let t0: Tuple::(Int Str)
t0
t0.left
t0.right
let t1: Tuple::(F32 S8)
t1
t1.left
t1.right