Major Milestone: Skink Has Officially Bootstrapped!

Woohoo! It’s time for a long-overdue update on the language powering the future of DANI.

We just crossed a monumental threshold with Skink: it is now officially bootstrapped!

For anyone unfamiliar with compiler development, bootstrapping means that the Skink compiler can now compile its own source code. From here on out, all future versions of the Skink compiler will be written in Skink itself. It’s a huge rite of passage for any programming language project, and seeing it actually work after so much foundation work is insanely satisfying.

Where Go Fits In (For Now)

The handover

Now, does this mean I’m throwing Go out the window today? Not quite!

Go has a proven, rock-solid track record, and I’ll be keeping it around for prototyping work. Whenever I want to test out an idea quickly and I’m not sure if Skink is quite ready to handle the heavy lifting yet, Go gives me a reliable safety net.

However, the long-term vision hasn't changed: eventually, I plan to fully commit to Skink for almost all development across my projects, experiments, and research.

The Road to Skink 1.0

While bootstrapping is a massive step forward, we aren't quite at version 1.0 just yet. To earn that release tag, Skink needs to hit a few crucial targets:

1. Cross-Platform Support: Clean cross-compilation across Windows, macOS, and Linux.
2. Architecture Support: Full targeting for both x86 and ARM architectures.
3. Embedded Target Transpilation: The ability to compile (or at least transpile down) to low-power platforms like the K210, ESP32, and standard Arduino C/C++.
4. Direct Hardware I/O: First-class hardware abstraction libraries for lower-level protocols—specifically I2C, SPI, GPIO, and related interfaces.

Acceleration, Compute, and Graphics Backends

Beyond microcontrollers and standard CPUs, getting high-performance compute and neural inference support hooked up is high on the priority list.

• CUDA Support: I still need to get CUDA fully enabled and tested. Because of my current local setup, this will likely require either acquiring new dedicated NVIDIA hardware or setting up a cloud-based VM for build and test pipelines.
• 
  Vulkan & AMD: My main local system currently relies on Vulkan to run LM Studio, so a Vulkan compute backend is high on the radar as a viable cross-vendor path. I'm also looking closely at AMD’s libraries (ROCm/HIP) to ensure broad hardware compatibility.

It's a lot of moving parts, but watching the architecture take shape piece by piece is incredibly rewarding.

Bringing It Back to DANI

So, why go through all the trouble of building a custom language from scratch?

It all comes down to DANI. My goal has always been to have a single, unified language capable of bridging every layer of DANI’s stack—from high-level logic and neural compute all the way down to real-time bare-metal sensor and actuator control. Skink is the key to making that happen without juggling three different language ecosystems.

Speaking of DANI, there have also been some fascinating developments regarding his neural network architecture recently... but I’ll leave you hanging on that for now and save the deep dive for the next post!

Stay tuned!

Introducing Skink-lang: Elegant Systems Programming for AI & Robotics (or, How to Stop DANI from Eating the Skirting Boards)

Over the last thirty years, I’ve worked across a sprawling landscape of technologies—from writing Go, C#, Pascal, Swift, and C, to orchestrating massive cloud pipelines, down to micro-managing registers on bare-metal microcontrollers.

But lately, my time has been dominated by a very specific, highly opinionated, and occasionally cooperative localized AI agent: DANI.

If you've been following my previous posts, you know DANI has transitioned from an LSTM-based cognitive core into a physical, moving entity. And that is where the real-world engineering headaches began. Every time you start a new robotics or physical AI project, you are forced to make a compromise that feels like choosing between a kick in the shins or a poke in the eye:

• The C/C++ Extremity: You get deterministic, blazing-fast performance on microcontrollers, but you sacrifice developer ergonomics, modern package safety, and swift prototyping. Writing raw $C++$ register manipulation code sometimes feels like trying to perform laparoscopic surgery on yourself with a rusty spoon.
• The Python Extremity: You get instant access to rich AI primitives, neural networks, and expressiveness. But you inherit bloated virtual environments that take up more disk space than the library of Alexandria, and unpredictable garbage collection (GC) latency. When DANI’s control loop is running at $100\text{ Hz}$ and the Python garbage collector decides to take a mandatory three-millisecond tea break, DANI doesn't stop. She gracefully, but deterministically, plows straight into the skirting board.

I got tired of choosing between developer speed and hardware execution safety. I wanted a compiled language built specifically for low-level systems hardware, high-throughput concurrent event streams, and native AI execution.

So, I built Skink-lang.

What is Skink?

Skink is an LLVM-backed, statically-typed systems programming language designed from the ground up for the modern era of intelligent automation. It blends the tight, expressive syntax of modern languages like Swift with the lightweight concurrency model of Go, leaving behind the runtime bloat.

To save you from the nightmare of modern package managers—where doing a pip install on a single helper utility somehow downloads half the internet and a bootleg copy of Doom—Skink comes with a rich, "batteries-included" standard library right out of the box.

As a Skinker (yes, that is our official title now), you get native access to:

1. Automatic Reference Counting (ARC): Predictable, deterministic memory management without "stop-the-world" garbage collection pauses. This is a non-negotiable requirement when you are driving physical motors or processing high-frequency sensor telemetry.
2. Lightweight Concurrency: A native spawn keyword that allows you to spin up millions of concurrent tasks with near-zero overhead, communicating cleanly via typed channels.
3. The Rules Engine: A compiler-optimized reactive rules engine that lets you define declarative behavioral overrides that monitor variables in the background. It is perfect for saying, "I don't care what the neural net is thinking; if we are $15\text{ cm}$ away from a wall, hit the brakes."
4. Native Tensors & ML Cores: Multi-dimensional arrays built directly into the type system via std/tensor, complete with matrix operations, activation functions, neural layers, and hooks for CUDA acceleration and llama.cpp (std/llm). DANI can run local inferences natively, at maximum speed, without needing a dedicated power plant or $16\text{ GB}$ of RAM.
5. Model Context Protocol (MCP) & MQTT: Built-in support for turning any hardware endpoint into an instantly discoverable AI tool with SQLite (std/db) and edge-to-cloud messaging (std/mqtt) ready to go.

Under the Hood: Preventing a DANI Catastrophe

To see what "skinking" actually looks like, let's write a syntactically valid program based on the current Skink manual.

The following script concurrently polls a physical distance sensor via GPIO, pipes the measurements to our main execution block using channels, evaluates safety overrides in a background ruleset, and processes the inputs through a linear neural network layer to calculate motor outputs:

module main

import "std/gpio"
import "std/time"
import "std/tensor"

// 1. Declare global state variables (accessible by the ruleset)
var current_distance: float = 100.0
var motor_speed: float = 0.5

// 2. Define a reactive ruleset for safety overrides
ruleset SafetyOverride {
    rule collision_warning when current_distance < 15.0 {
        action: trigger_emergency_stop()
        priority: 1
    }
}

// Helper function called when the rule fires
fn trigger_emergency_stop() {
    motor_speed = 0.0
    print("SAFETY OVERRIDE: Obstacle detected! Distance: {current_distance}cm. Braking.")
}

// 3. Concurrently poll the hardware sensor in a background task
fn sensor_loop(ch: chan<float>) {
    err := gpio.Setup()
    if err.message != "" {
        print("Failed to initialize GPIO: " + err.message)
        return
    }

    // Bind to BCM Pin 17 (e.g., our sensor input pin)
    sensor_pin := gpio.PinFactory(17)
    sensor_pin.SetInput()

    while true {
        // Mocking a physical sensor read for this demo loop
        // In physical deployment, you'd calculate raw voltage pulses here
        measured := 12.5 
        ch <- measured
        time.SleepMs(10) // Poll at 100Hz
    }
}

// 4. Main Entry Point
fn main() -> int {
    sensor_chan := make(chan<float>)

    // Spawn our lightweight background polling loop
    spawn sensor_loop(sensor_chan)

    // Activate our safety ruleset background thread
    safety := SafetyOverride{}
    safety.start()
    defer safety.stop()

    // Initialize a linear neural network layer [input_features: 3, output_features: 1]
    layer := tensor.NewLinear(3, 1)

    // Run our control loop for 100 iterations
    for i := 0; i < 100; i = i + 1 {
        // Block until next sensor reading arrives
        current_distance = <-sensor_chan

        // If we are in a safe zone, let the tensor neural layer drive
        if current_distance >= 15.0 {
            input := tensor.Zeros([1, 3])
            input.Set([0, 0], current_distance)
           
            output := layer.Forward(input)
            motor_speed = output.Get([0, 0])
           
            print("Processing... Current motor velocity: {motor_speed}")
        }
    }
    return 0
}

Notice how neatly this handles the classic embedded AI problem. The concurrency model lets you poll hardware safely on separate execution threads without blocking the main loop, while the native ruleset watches the critical state variables and takes action within milliseconds if a threshold is breached—guaranteeing deterministic safety constraints before DANI can do any structural damage to the house.

Where Skink-lang Goes From Here

Currently, the compiler is bootstrapped in Go, using an LLVM backend to output highly optimized native machine binaries targeting both Linux and Windows corporate environments. Because there is no heavy runtime or garbage collector, a compiled Skink binary running an active inference loop can comfortably squeeze inside less than $128\text{ KB}$ of RAM.

But this is just the beginning. The roadmap ahead includes:

• Direct Single Board Computer HAL: Expanding the standard library to map hardware registers and pins natively (such as on the Raspberry Pi 5) with zero external C-bindings.
• Self-Hosting: Rewriting the Skink compiler entirely in Skink itself, proving the language's capabilities to handle massive, complex systems-level software natively.

Cullen Skink

I’m incredibly excited about what this language makes possible. DANI is already running much cooler, much faster, and with a significantly lower skirting-board collision rate.

It is time to stop fighting the plumbing.

Let's get skinking!

Let me know your thoughts on the syntax, and what features you'd like to see added to the compiler next!

Vibe Coding: The Future of Programming or Just a Fun Experiment?

Heard the latest buzzword in the tech world? It's "Vibe Coding". When I first encountered the term, my mind instantly pictured a programmer just winging it, letting the code flow wherever the digital current took them, maybe like a novelist surprised by their own characters. I'll admit, I've had moments like that – a vague goal in mind and just… coding.   

But, as it turns out, that initial guess was off the mark. So, what is vibe coding? According to the collective wisdom of Wikipedia:   

“Vibe coding (also vibecoding) is an AI-dependent programming technique where a person describes a problem in a few sentences as a prompt to a large language model (LLM) tuned for coding. The LLM generates software, shifting the programmer's role from manual coding to guiding, testing, and refining the AI-generated source code. Vibe coding is claimed by its advocates to allow even amateur programmers to produce software without the extensive training and skills required for software engineering”    

Essentially, you tell an AI what you want, and poof, it generates the code. The human becomes less of a manual coder and more of a guide, tester, and refiner. Sounds pretty cool, right? Maybe even revolutionary?   

The Allure and the Alarm Bells

I can definitely see the appeal. It sounds fun, potentially lowering the barrier to entry for software creation and offering a fascinating avenue for exploring AI capabilities. Imagine describing an app idea and having a functional starting point within minutes!   

However, based on my experience and reading, I'm not convinced it's a truly viable solution just yet. Why the hesitation?   

It Often Doesn't "Just Work": Getting AI-generated code that runs correctly the first time seems to be the exception, not the rule. It often takes several tries, tweaking prompts to get something functional.   

Functionality vs. Intent: Even if the code runs, does it actually do what you intended? That's another hurdle where luck plays a big role.   

The Amendment Nightmare: Here's the real kicker for me: trying to modify or fix AI-generated code. If you stick with vibe coding, you could end up in an endless loop of refining prompts for a single feature. Try to dive in manually? You might find code that, while functional, is baffling, overly rigid because it stuck too literally to your prompt, or just plain inefficient.   

So, Where Do We Stand?

Vibe coding is undeniably intriguing. As a tool for rapid prototyping, learning, or exploring AI's coding prowess, it has potential. But relying on it for serious development seems fraught with challenges, particularly when it comes to refinement and maintenance.   

Perhaps it's less about replacing traditional coding and more about augmenting it – a powerful assistant, but one whose work needs careful scrutiny and often, significant manual intervention.

What are your thoughts? Have you tried vibe coding? Is it the future, a fleeting trend, or something in between? Let me know in the comments!

A Commentary: The Lost Art of Building from the Ground Up

If you've taken a peek at my bio, you'll know I've been programming and wrestling with code for a good long while. And when I say "programming," I'm not just talking about typing out lines of code. That's the easy part, honestly. But I digress.

What's been on my mind lately is the growing number of developers – and let's lump programmers, coders, and even those "script kiddies" into one big, friendly group – entering the industry with a heavy, sometimes too heavy, reliance on the current favourite framework or that magical library that makes life easier. Don't get me wrong, these tools are fantastic. I use libraries in almost all my projects. But here's the rub: many of today's rising talents seem unable to build anything without them.

Over the past decade, I've seen this reliance grow, while the fundamental skills of building without these crutches seem to be fading. I learned my craft before most of these libraries even existed. Heck, I recently realized I'm older than C++! I was a year old when Dennis Ritchie invented C at Bell Labs. So, I had no choice but to learn things from the ground up.

I had to master the basics. And I'm not talking about assembly or machine code, though I can still wrangle 6502 assembly. I mean understanding how to make a language do what you want with its core features, no external libraries or frameworks. I can already hear the C, Go, and Rust folks saying, "But <insert language here> provides standard libraries!" And you're right, but that's not what I'm talking about. I'm referring to those third-party libraries and frameworks you install separately. Some have become so ingrained in our workflow that they're almost mistaken for the language itself (looking at you, jQuery).

Take JavaScript, for example. I've written tons of it over the years. Sure, I could use React, and I probably will at some point. But for everything React does, and it does it well, I've likely built something similar in plain, native JavaScript. The same goes for Go, C++, or any other language I've worked with. I like to know how things work; I don't trust black boxes I can't peek inside.

I've worked with many talented university graduates who can create impressive projects. The UI is slick, the responsiveness is spot-on. But when something goes wrong, especially if it's within a library they're using, they hit a wall. And if you ask them to modify something built without their favourite framework, it takes far longer than it should. A solid grasp of the language's fundamentals is always essential.

So, how does this relate to my current projects? Well, I'm obviously going to be leaning on neural networks for a lot of the heavy lifting, likely recurrent neural networks. But before I even started this project, I knew I'd be using them. It's just the direction things are heading. To prepare for the onslaught of libraries and frameworks (like TensorFlow) in this area, I decided to build my own.

Let me be clear: my neural network is nowhere near as sophisticated as TensorFlow. For my limited dataset, I could probably have written a traditional program faster and more accurately. But that wasn't the point. The goal was to understand what's happening inside those infamous "black boxes."

I've since refined my network with concurrency and better activation functions, but that's just icing on the cake. By learning how these networks work, even at a basic level, I'm much more comfortable using them in my projects. I might even have to create my own, as I'm not sure there's one that perfectly fits my needs, but now I feel equipped to do so.

So, if I could offer one piece of advice (and I have many, but we'll stick to one for now), it would be this: Learn the basics. Get a book on the core language before diving into frameworks. If you need to learn a specific algorithm, try building it yourself first, without any external libraries. It doesn't have to be perfect, or even good. But by doing so, you'll gain a much deeper understanding of what those libraries are doing under the hood. Maybe not the exact details, but you'll have a solid conceptual grasp.

Don't let the convenience of libraries and frameworks replace the satisfaction of building something from the ground up. You might be surprised at what you can achieve.

Whether you agree, or disagree, I would love to hear your thoughts 👇

And yes, that is an AI generated image 😁