---
title: "Nubo: My Fun Little Programming Language Project"
description: "Nubo is a small programming language project I made for fun."
slug: "nubo-my-fun-little-programming-language-project"
published: true
read_time: 4
created_at: "2026-06-25 16:53:26.515 +0000 UTC"
updated_at: "2026-07-09 16:01:50.846 +0000 UTC"
author: "Martin Binder"
author_url: "https://scrib.ee/_id/martin"
tags:
- "Nubo"
---
# Nubo: My Fun Little Programming Language Project
Nubo is a small programming language project I made for fun.
It is not trying to replace every programming language.
It is more like a playground where I can try language ideas, build scripts, render HTML, make small web apps, and experiment with how a language could feel.
The main goal is simple: make coding feel clean, readable, and enjoyable.
## What is Nubo?
Nubo is a programming language with a simple syntax and some web-friendly features.
You can write normal code like this:
```tsx
const name = "Nubo"
let count = 0
println(`Hello from {name}`)
```
It has variables, functions, loops, imports, types, arrays, dictionaries, and other basic language features.
But it also has some extra things that make it fun, like built-in HTML support.
## Why I Built It
I built Nubo because programming languages are fun.
I wanted to understand how languages work internally: parsing, evaluating code, handling variables, imports, functions, types, and all the little details that usually stay hidden.
Nubo started as an experiment, but it became a real little language that can run scripts and even build small web apps.
It is still a fun project, but it is also useful enough to make real demos with.
## The Core is Nubo
For real expression operations like `+`, `-`, comparisons, and similar calculations, Nubo uses [expr-lang/expr](https://github.com/expr-lang/expr).
That helps with evaluating expressions reliably instead of reinventing every tiny operation from scratch.
But the core language is still Nubo.
The syntax, imports, functions, HTML templates, components, routing ideas, and the way `.nubo` files work are all part of Nubo itself.
So expr helps with expression evaluation, but Nubo is the actual language around it.
## Simple Scripts
Nubo works nicely for scripts.
For example, you can read data, loop through it, count values, and print results:
```tsx
for item in data {
const author = item[4][0]
if author.includes(input) {
count++
}
}
```
This kind of code is simple, but that is the point. Nubo is meant to keep small tasks readable.
It is good for experimenting, school-style tasks, data processing, and quick automation.
## Built-in HTML
One of my favorite parts of Nubo is that HTML can be written directly inside the language.
```tsx
const page =
Hello Nubo
This HTML is written inside Nubo.
```
This makes it possible to build pages without switching between a separate template language and normal code.
HTML feels like a natural part of the language.
## Components as Functions
Nubo can also use functions as components.
```tsx
fn Button(text: string) html {
return
}
```
This makes UI code easy to split into smaller pieces.
A layout, form, copy box, table, or full page can just be a function that returns HTML.
That makes Nubo fun for small web apps, because the structure stays very simple.
## Web App Experiments
Nubo can also be used for small server-side web apps.
One demo project is a URL shortener. It has a form, app logic, a small database layer, reusable components, and redirects.
That project shows the direction I want Nubo to explore: small apps that do not need a huge framework to feel organized.
You can write a route, read a request, call some app logic, and return HTML.
That is simple, but powerful enough for fun projects.
## Imports and Standard Libraries
Nubo supports imports from local files and standard libraries.
```tsx
import io from "@std/io"
import request from "@server/request"
import { redirect } from "@server/response"
```
This makes projects easier to split up.
Helpers can go in one file, components in another, app logic somewhere else, and the main route can stay clean.
## Typed, But Still Lightweight
Nubo has types, but it tries not to feel too heavy.
```tsx
const numbers: []int = []
let code: string? = nil
```
Types help make the code clearer, especially when working with arrays, dictionaries, functions, and optional values.
But the language still tries to stay small and easy to read.
## What Makes Nubo Fun
Nubo is fun because it mixes a few different ideas:
- scripting
- typed values
- imports
- built-in HTML
- reusable components
- server-side routes
- simple app structure
- expression evaluation powered by expr
- a custom language core
It is a small project, but it already has enough features to build interesting things.
## Final Thoughts
Nubo is still young, but that is part of the fun.
It is a project for learning, experimenting, and building small things in a language that feels personal.
The best part is that it keeps growing. Every feature teaches something new about how programming languages work.
Nubo may not be a huge language, but it has its own style: simple syntax, readable code, HTML built in, and a core built around experimenting with fun ideas.