DEV Community: jj

Meet the Schizophrenic Programmer Who Made His Own Language

jj — Sun, 18 Oct 2026 20:00:28 +0000

At 18 years old, Jack Waechter has built his own compiled programming language, plays guitar in a black metal band, and is learning to live with schizophrenia. He's been programming since he was 12, and he's only getting started.

Most 18-year-olds aren't spending their free time writing compilers, building programming languages, or figuring out how to generate machine code.

But Jack Waechter, a young programmer from Chesterton, Indiana, has spent the last several years doing exactly that.

He's the creator of Sere, a programming language that combines Python-inspired syntax with native compilation through LLVM. It has its own compiler, runtime, type system, and an extensive standard library.

He's also a black metal musician, a guitarist, and someone who has spent a significant part of his teenage years struggling with schizophrenia.

Jack was diagnosed with schizoaffective disorder and has been undergoing treatment, with positive results.

His life hasn't exactly been straightforward, but through everything, programming and music have remained two of his biggest passions.

It started with Python at 12

Jack began teaching himself programming when he was 12 years old.

Like a lot of people getting into programming, he started with Python. He learned by reading documentation, experimenting with code, and building things simply because he was curious about how they worked.

But he eventually became more interested in the tools behind programming than just the programs themselves.

He wanted to know how a computer understood code in the first place.

How does a programming language work? How does a compiler turn text into executable instructions? Could he write one himself?

By the time he was 14, he had written his first compiler.

It wasn't the end of his interest in language development. It was really just the beginning.

Over the following years, Jack continued studying compiler architecture, programming language design, and low-level systems programming.

Eventually, he decided to create something much more ambitious: a programming language that people could actually install and use.

That project became Sere.

Sere: Python-like syntax, native compilation

Sere is a statically typed, compiled programming language written in C++ and powered by LLVM.

The idea behind it is relatively simple. Jack wanted a language that was pleasant to write, like Python, but with the performance and low-level capabilities associated with compiled languages.

For example, a basic Sere program looks like this:

def greet(name: str) -> void:
    print(f"Hello, {name}!")

def main() -> i32:
    greet("World")
    return 0

Anyone familiar with Python will recognize the syntax.

But unlike Python, Sere compiles programs into native machine code rather than running them through an interpreter.

It has static typing, type inference, classes, pointers, asynchronous programming support, and its own compilation infrastructure.

One of the more interesting parts of Sere is its standard library.

Jack has been building it largely around the things he personally wants from a programming language. That includes OpenGL bindings for graphics programming, custom audio libraries, multiprocessing, matrix mathematics, and many other modules.

He has also implemented a project system and a library format called .slib, allowing developers to package and reuse Sere code.

And this isn't just a language that exists as a collection of unfinished source files.

Sere can be downloaded, installed, and used to build actual programs.

Of course, it's still an independently developed language. There are bugs, unfinished features, and plenty of improvements that need to be made.

But Jack is actively developing it, and the source code is publicly available.

Website: https://sere-lang.com

GitHub: https://github.com/Sere-Language/sere

Programming while struggling with schizophrenia

There's another part of Jack's life that he's been open about.

He struggles with schizophrenia.

He was diagnosed with schizoaffective disorder, and his mental health has been a significant challenge throughout his teenage years.

Schizophrenia can affect almost every aspect of a person's life. For Jack, dealing with his symptoms while trying to maintain his interests, work on projects, and enjoy everyday life hasn't always been easy.

Some days are harder than others.

Programming itself can require hours of concentration, patience, and problem-solving. Compiler development is especially demanding, since even a small mistake can lead to complicated bugs that take hours to track down.

Trying to manage a serious mental illness alongside that kind of work comes with its own difficulties.

But Jack hasn't stopped doing what he enjoys.

He's continued developing Sere, experimenting with new projects, and spending time making music.

He's also been receiving psychiatric treatment and has been experiencing positive outcomes.

Things have been improving, even if there are still challenges.

And while his programming accomplishments are impressive, they're not what makes his experience with schizophrenia worth talking about.

What matters is that he's continuing to find things he enjoys and wants to pursue, even while dealing with an illness that can make ordinary life difficult.

Schizophrenia carries a lot of stigma. People often make assumptions about someone's intelligence, personality, or future as soon as they hear the diagnosis.

Jack's life is a good example of why those assumptions don't tell the whole story.

He's a programmer. He's a musician. He's someone who likes building things and learning how they work.

Schizophrenia is part of his life, but it isn't his entire identity.

When he's not programming, he's playing black metal

Jack's interests go well beyond computers.

He's a guitarist in Vesperá, a black metal band, and he's also a big fan of hardcore punk.

It's an interesting contrast. One day he might be working through a difficult compiler bug, and the next he's playing guitar or working on music.

But both are things he genuinely enjoys.

Music gives him another creative outlet, something completely separate from writing software.

And in a way, the two hobbies have quite a bit in common. Both involve experimenting, learning techniques, developing your own style, and spending a ridiculous amount of time getting small details right.

Jack isn't just interested in programming because it's a potential career.

He likes creating things.

Whether that's a new feature in Sere, a piece of software, or music with his band, the process of making something is a big part of what keeps him interested.

He livestreams his development

Jack also runs a YouTube channel called CompilerMan, where he livestreams his programming and development work.

People can watch him work on Sere, implement features, fix bugs, and experiment with different parts of the language.

And like any real programming project, things don't always go according to plan.

Compiler development can be frustrating. A seemingly simple feature might require changes across several different parts of the compiler. Fixing one bug can introduce another.

Sometimes an entire development session gets spent trying to understand why something that should work simply doesn't.

But that's what makes watching the development process interesting.

Instead of only showing polished releases, Jack shares the actual work involved in building a programming language.

For people interested in compilers, programming languages, or systems programming, it's a chance to see someone actively working on a project like this.

His channel can be found here:

CompilerMan on YouTube

There's more to someone than their diagnosis

One of the reasons Jack's story is worth sharing is that schizophrenia is still widely misunderstood.

When people hear the word, they often think of the worst possible examples they've seen in movies or on television.

They don't necessarily picture an 18-year-old sitting at his computer, debugging LLVM code, writing a graphics library, or playing black metal guitar.

But people with schizophrenia have hobbies, interests, personalities, ambitions, and lives outside of their illness.

Jack's no different.

He's had to deal with some difficult experiences, and his mental health remains something he has to take seriously.

But he's also spent years learning a difficult area of computer science and turning that knowledge into something other people can use.

That doesn't mean everyone with schizophrenia should be expected to accomplish something extraordinary.

Nobody should have to prove their worth through productivity or achievements.

Sometimes simply making it through a difficult period and finding the right treatment is a major accomplishment on its own.

For Jack, improving his mental health and continuing to work on the things he loves have both been important parts of moving forward.

His diagnosis hasn't erased his curiosity or his interest in creating things.

And as his treatment continues to help, he's looking toward the future.

What's next for Jack and Sere?

Sere is still being actively developed.

Jack continues to expand its standard library, improve the compiler, work on performance, and add features that make the language more practical for everyday development.

There's no telling exactly where the project will end up.

Maybe Sere will eventually attract a larger community of developers. Maybe it'll remain a smaller independent language with a dedicated group of users.

Either way, Jack has already learned an enormous amount from building it.

And at 18, he has plenty of time to keep learning.

Six years ago, he was a 12-year-old teaching himself Python.

Two years later, he had written his first compiler.

Now he has his own programming language, a public GitHub repository, and people who can actually download and use what he's created.

At the same time, he's continuing to work on his mental health, play music, and figure out what he wants to do with his life.

His story isn't about overcoming schizophrenia through programming. It's about someone who happens to have schizophrenia and still has things he loves doing.

For anyone who's struggling with their own mental health, that's something worth remembering.

Having a serious illness doesn't mean your future is already decided. It doesn't mean you can't learn something new, pursue a hobby, or work toward something you care about.

Progress might be slow. There might be setbacks. Some days, taking care of yourself needs to come before everything else.

But improvement is possible, and there's still a lot of life to experience.

Jack's still figuring things out himself.

For now, he's going to keep writing code, making music, and working on Sere.

And considering how much he's already done at 18, it'll be interesting to see where he takes it next.

Follow Jack's work

If you're interested in Sere, compiler development, or just want to see what Jack is working on, you can find his projects here:

Sere website: https://sere-lang.com
Sere GitHub: https://github.com/Sere-Language/sere
YouTube: https://www.youtube.com/@compilerman2254/videos
Vesperá: https://www.metal-archives.com/bands/Vesper%C3%A1/3540543795

Sere is open source, and developers are welcome to explore the code, try the language, report bugs, and contribute to the project.

Aphelion Editor - A free node-based video / VFX editor

jj — Mon, 21 Sep 2026 05:21:16 +0000

Introducing Aphelion Editor: An Open-Source Node-Based Video Editor

I’ve been working on Aphelion Editor, an open-source, node-based video editing application built around the idea that editing video should feel more programmable, visual, and flexible.

Instead of organizing everything around a traditional timeline, Aphelion lets you build your video processing pipeline using nodes.

You connect inputs, effects, transforms, tracking, audio, and output nodes together to describe how your final video should be produced.

GitHub: https://github.com/aphelion-engine/aphelion-editor

Why I Built It

Most video editors are incredibly capable, but their workflows are usually centered around timelines, tracks, layers, and panels.

I wanted to experiment with something different.

What if editing a video felt closer to building a shader graph, Blender node tree, or visual program?

That idea became Aphelion.

The goal is not just to make another basic video editor. I want Aphelion to eventually become a serious node-based environment for compositing, effects, motion graphics, tracking, audio processing, automation, and general video production.

How It Works

Aphelion represents a project as a graph.

A simple workflow might look something like:

Video Input
    |
    v
Transform
    |
    v
Color Correction
    |
    v
Sharpen
    |
    v
Video Output

More complex projects can branch, combine multiple sources, reuse processing chains, and expose parameters that can be animated over time.

This makes the structure of an effect much easier to see.

Instead of hunting through several menus to figure out what is happening to a clip, you can follow the graph.

Current Features

Aphelion already includes a growing set of editing and compositing functionality.

Some of the current features include:

Node-based project graphs
Video input and decoding
Audio decoding and playback support
Frame-by-frame evaluation
Image and video processing nodes
Animatable numeric and slider properties
Keyframing
Point tracking
Planar tracking work
Exposure controls
Horizontal and vertical flipping
Frame offsets
Playback speed controls
Source FPS handling
Video fitting modes
Media metadata probing
Plugin support
Project validation
A custom .aph project format
A growing built-in node library

The editor is written primarily in Python using PyQt6, with NumPy, OpenCV, FFmpeg-based media tooling, and other libraries handling the heavier media processing work.

Tracking

One area I’ve been spending a lot of time on is tracking.

Aphelion currently has point-tracking infrastructure that can follow features through a sequence of frames.

The longer-term goal is to make tracking data reusable throughout the graph.

For example:

Video Input
     |
     +------> Point Tracker
     |             |
     |             v
     |        Tracking Data
     |             |
     v             v
Transform <---------
     |
     v
Output

That opens the door to things like automatically attaching text to objects, stabilizing footage, following faces or objects, masking moving regions, and driving effect parameters from tracked motion.

Audio Is Part of the Graph Too

Video editing is not only about frames.

Aphelion's evaluation system can carry synchronized audio alongside video, allowing nodes and playback systems to work with both.

Internally, evaluated media can contain a video frame along with an audio sample slice associated with that frame.

That architecture should eventually allow dedicated audio nodes for things like:

Gain
EQ
Compression
Filtering
Mixing
Audio-reactive effects
Waveform visualization
Automation

I want audio to feel like a first-class part of the editor rather than something bolted onto the side.

Plugins

Another major goal is extensibility.

Aphelion includes a plugin system so that the node library does not have to be limited to whatever ships with the editor.

Eventually, I want developers to be able to create their own nodes for things like:

@node
class MyEffect:
    def process(self, frame, intensity):
        # custom processing
        return frame

That could include effects, generators, AI tools, codecs, analysis nodes, automation tools, custom UI controls, and more.

A video editor gets dramatically more interesting once users can extend it themselves.

Performance Is One of the Biggest Challenges

Building the UI was not the hardest part.

Making a node-based video editor actually play video smoothly is.

A graph may contain several expensive operations for every frame:

decode
 -> resize
 -> transform
 -> tracking
 -> blur
 -> color correction
 -> compositing
 -> preview

At 60 FPS, that entire pipeline has roughly 16 milliseconds to complete if you want real-time playback.

Python makes prototyping incredibly fast, but it also means I have to be careful about where processing happens.

I’ve been working on things like caching, prefetching, asynchronous media decoding, lower-resolution previews, reducing unnecessary graph evaluation, and moving expensive operations into optimized native libraries.

Long-term, I also want to explore GPU-backed processing.

There is a lot of optimization work left to do, but honestly, that is one of the parts of the project I find most interesting.

The Project Format

Aphelion projects use a dedicated .aph project format.

A project stores information such as:

Nodes
Connections
Node properties
Media references
Animation data
Project configuration

The graph is also validated when projects are opened to help catch invalid or broken connections before evaluation.

The format is still evolving as the editor grows.

Where I Want to Take Aphelion

There is still a huge amount I want to build.

Some of the areas I’m interested in include:

GPU-accelerated effects
Better real-time playback
Advanced compositing
Masks and rotoscoping
Motion tracking
Better planar tracking
Motion graphics
Text and typography tools
Audio processing nodes
Proxy media
Render queues
Background rendering
Custom node scripting
More plugin APIs
Color grading tools
LUT support
Hardware encoding and decoding
Improved caching
Optical flow
Time remapping
Expressions
More advanced animation tools

Ultimately, I want Aphelion to sit somewhere between a video editor, compositor, and visual programming environment.

Open Source

Aphelion is open source, and that is a major part of the project.

I want people to be able to dig into the code, experiment with the architecture, build nodes, improve performance, fix bugs, and shape where the editor goes.

There are a lot of interesting problems involved in building something like this: media decoding, caching, graph evaluation, synchronization, rendering, UI architecture, tracking, audio, plugins, and performance.

If any of those areas sound interesting, contributions are welcome.

GitHub:

https://github.com/aphelion-engine/aphelion-editor

Download from the Website:

https://aphelion-community.com

The project is still early, but it has reached the point where it is becoming something much bigger than the original experiment.

I’m excited to keep pushing it forward.

Introducing Sere: a compiled language with Python-like syntax and systems-level power

jj — Mon, 14 Sep 2026 02:07:22 +0000

Today I’m launching Sere, a compiled programming language built around a simple idea:

Python-like readability shouldn’t mean giving up native performance, static typing, or low-level control.

Sere is designed to feel familiar and lightweight while still giving you the kinds of capabilities you’d normally reach for C++, Rust, or Zig to get.

A basic Sere program looks like this:

def main() -> i32:
    print("hello from sere")
    return 0

You can define structs and methods without much ceremony:

struct Point:
    x: i32
    y: i32

    def length_sq(self) -> i32:
        return self.x * self.x + self.y * self.y

def main() -> i32:
    p = Point(3, 4)

    print(p.length_sq())
    return 0

Under the hood, Sere is a native compiled language built on LLVM.

That means you can go from readable high-level code to actual native binaries:

sere main.sere -o main.exe

You can also inspect LLVM IR or generated assembly:

sere --emit-llvm main.sere -o main.ll
sere --emit-asm main.sere -o main.s

Built for more than scripting

Sere isn’t meant to be “Python with a compiler.”

The goal is to support real systems-level work while keeping the syntax approachable.

That includes explicit memory control:

owned: Unique[i32] = unique[i32](42)

*owned = 100

value: i32 = load(owned)

Raw pointers are available when you actually need them:

ptr: Ptr[i32] = alloc[i32]()

store(ptr, 123)

print(*ptr)

free(ptr)

And the language includes modern features like enums and pattern matching:

enum Message:
    Quit
    Move(x: i32, y: i32)

def handle(msg: Message) -> void:
    match msg:
        case Message.Quit:
            print("bye")

        case Message.Move(x, y):
            print(f"moving to {x}, {y}")

Tooling matters too

I don’t want Sere to be one of those languages where the compiler exists but the developer experience feels like 2008.

Sere already has tooling for:

syntax highlighting
diagnostics
hover information
go to definition
rename
VS Code integration
project builds
library packaging

Libraries can be packaged into .slib files and imported into other Sere projects:

sere init-lib mathlib
sere pack

Then:

import mathlib

def main() -> i32:
    print(mathlib.add(2, 3))
    return 0

Native interoperability is also a major part of the project. Sere is being built with C and C++ interop in mind rather than pretending the existing native ecosystem doesn’t exist.

What Sere is trying to be

The goal is not to replace Python, C++, or Rust.

It’s to explore a different balance between them.

I want Sere to be a language where this feels normal:

items = [1, 2, 3]

for item in items:
    print(item)

while this is still possible:

buffer: Ptr[u8] = alloc[u8](1024)

High-level when you want it.

Low-level when you need it.

Without turning every program into a wall of syntax.

Sere is still early

Sere is actively being developed, and I’m not going to pretend otherwise.

There are still bugs, missing features, compiler edge cases, and parts of the ecosystem that need a lot more work.

But the language is at a point where people can actually download it, write code, compile native programs, build libraries, and experiment with the design.

That’s why I’m launching it publicly now.

I want feedback while the language is still flexible enough to change.

If something is confusing, awkward, broken, or just a terrible language-design decision, I want to hear about it.

Try Sere

Website:

https://sere-lang.com

GitHub:

https://github.com/Sere-Language/sere

Sere is open source, and contributors are welcome.

If you’re interested in compilers, LLVM, programming language design, systems programming, or just trying new languages, I’d love for you to give it a shot and tell me what you think.

Python-like syntax. Native compilation. Systems-level control.

That’s the direction I’m building Sere toward.