u/kostrubaty

Ok so I started looking into VM, hoping to find anything useful. My first idea was to try and find correlation between words on the page and the presented imagery. For that I've used qwen3 vl to generate two datasets (one based on strict schema following common patterns in the imagery) and also a simple keyword based list of visual objects.

Ran the correlation test, aand nothing survived the permutation checks. So seemingly there is zero correlation between text and the imagery which is our clue #1.

So next step was runnning statistical analysis for character entropy, mean word length etc.
Here some things are clearly visible:
2. Text from all five identified scribes have exact same artificial fingerprint (suggesting shared methodology).
3. Structure is sequential not positional.

So this led to a clear candidate for text generating method -> a simple markov chain. But pure markov chain characteristics turned out to be slightly different. After adding just ~0.15 chance of self citation within last 25 words the results matched perfectly.

Code, vl datasets, detailed findings can be found here: https://github.com/karolrybak/voynichese/tree/master

As for the question from the title. You'll have to answer that yourself, here's just my 2 cents.

*Currently we have varying level of support for 15 source languages (using treesitter) and 18 different targets.

schema-pop library, offers even more functionality like automatic migrations for schema versioning, clang importer. And there's still more to come, so stay tuned.

Support for different languages is tiered, core is: c, c++, zig, rust, go and ts. I aim for 100% compatibility for those.

Everything is written in pure typescript with erasable syntax and ultra strict settings. All generated code is standalone with zero external dependencies.

e2e testing via binary harness compilation for core langs. This includes schema generation, decoding randomized data, migrations.

Current version is not yet fully stable, I'm working to fill in some remaining gaps in functionality and fully stabilizing api's and schemas in 0.2.0

Let me know what you think! If you have any questions -> I'm here :)

Hi everyone, I'm working on my pet project, which I use to generate binary codec. I'm wondering if this is absolutely fastest way to decode with ts. Also pondering about compiling those into standalone pieces of C-compiled binary as it wouldn't be that hard to generate C code instead of TS,

So my question is, are there better ways to solve that? Also is the C path worth it at all? Or is V8 good enough so there won't be a real distance.

export const CommandTag = {
	ConstraintCommand: 0,
	ParticleCommand: 1,
} as const;
export type CommandTag = "ConstraintCommand" | "ParticleCommand";

export function deserializeCommandTag(view: DataView, offset: number): CommandTag {
	const val = view.getUint8(offset);
	switch (val) {
		case 0: return "ConstraintCommand";
		case 1: return "ParticleCommand";
		default: throw new Error("Unknown enum val: " + val);
	}
}
export function serializeCommandTag(val: CommandTag, view: DataView, offset: number): void {
	let num = 0;
	switch (val) {
		case "ConstraintCommand": num = 0; break;
		case "ParticleCommand": num = 1; break;
	}
	view.setUint8(offset, num);
}

export type vec2 = number[];
export function deserializevec2(view: DataView, offset: number, outObj?: vec2): vec2 {
	outObj = outObj ?? (new Array(2) as vec2);
	for (let i = 0; i < 2; i++) {
		const itemOffset = offset + (i * 4);
		outObj[i] = view.getFloat32(itemOffset, true);
	}
	return outObj;
}
export function serializevec2(val: vec2, view: DataView, offset: number): void {
	{
		for (let i = 0; i < 2; i++) {
			const itemOffset = offset + (i * 4);
			view.setFloat32(itemOffset, val[i], true);
		}
	}
}

export interface Particle {
	friction: number;
	mass: number;
	object_data: number;
	pos: vec2;
	prevPos: vec2;
	radius: number;
}
export function deserializeParticle(view: DataView, offset: number, outObj?: Particle): Particle {
	outObj = outObj ?? ({} as Particle);
	outObj.friction = view.getFloat32(offset + 0, true);
	outObj.mass = view.getFloat32(offset + 4, true);
	outObj.object_data = view.getUint32(offset + 8, true);
	outObj.pos = deserializevec2(view, offset + 16, outObj.pos);
	outObj.prevPos = deserializevec2(view, offset + 24, outObj.prevPos);
	outObj.radius = view.getFloat32(offset + 32, true);
	return outObj;
}

export function serializeParticle(val: Particle, view: DataView, offset: number): void {
	view.setFloat32(offset + 0, val.friction, true);
	view.setFloat32(offset + 4, val.mass, true);
	view.setUint32(offset + 8, val.object_data, true);
	serializevec2(val.pos, view, offset + 16);
	serializevec2(val.prevPos, view, offset + 24);
	view.setFloat32(offset + 32, val.radius, true);
}