The gist of it is I wanted C+- but with Python syntax. So I made that. It is nice.

Dudu looks like Python.

Dudu uses Python-style indentation, functions, calls, classes, loops, named arguments, imports, and indexing.

def clamp(value: int, low: int, high: int) -> int:
    if value < low:
        return low
    if value > high:
        return high
    return value

def clamp(value: i32, low: i32, high: i32) -> i32:
    if value < low:
        return low
    if value > high:
        return high
    return value

class Player:
    def __init__(self, name: str, hp: int):
        self.name = name
        self.hp = hp

    def damage(self, amount: int):
        self.hp -= amount

class Player:
    name: str
    hp: i32

    def damage(self, amount: i32):
        self.hp -= amount

player = Player(name="Ada", hp=100)

from renderer.camera import Camera
camera = Camera()

from renderer.camera import Camera
camera = Camera()

This is source familiarity, not Python compatibility. Dudu is statically typed and has native value, reference, pointer, and lifetime behavior.

Differences from Python.

Some differences are required for static compilation. Others remove syntax that I don't want in Dudu.

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

class Point:
    x: f32
    y: f32

point = Point(x=2.0, y=4.0)

class Buffer:
    def __init__(self, values: list[int]):
        self.values = values

    def __len__(self):
        return len(self.values)

    def __getitem__(self, index):
        return self.values[index]

    def __setitem__(self, index, value):
        self.values[index] = value

    def __add__(self, other):
        return Buffer(self.values + other.values)

class Buffer:
    values: list[i32]

    def size(self) -> usize:
        return len(self.values)

    @operator("[]")
    def get(self, index: usize) -> i32:
        return self.values[index]

    @operator("[]=")
    def set(self, index: usize, value: i32):
        self.values[index] = value

    @operator("+")
    def add(self, other: Buffer) -> Buffer:
        combined: list[i32] = []
        for value in self.values:
            combined.append(value)
        for value in other.values:
            combined.append(value)
        return Buffer(values=combined)

health: int = "probably fine"
health += 1  # fails only when executed

health: i32 = "probably fine"
# cannot assign str to i32

value = 10
value = "ten"
value = Player()

value = 10
value = "ten"
# cannot assign str to i32

players: list[Player] = [
    Player("Ada", 100),
    Player("Lin", 80),
]
players.append(Player("Grace", 90))

players: list[Player] = [
    Player(name="Ada", hp=100),
    Player(name="Lin", hp=80),
]
players.append(Player(name="Grace", hp=90))

items = [10, "ten", Player("Ada", 100)]
items.append(4.5)

enum Item:
    Integer:
        value: i32
    Text:
        value: str
    PlayerValue:
        value: Player

items: list[Item] = [
    Item.Integer(value=10),
    Item.Text(value="ten"),
    Item.PlayerValue(value=Player(name="Ada", hp=100)),
]

class Player:
    name: str
    extra_state: dict[str, bool]

    def __init__(self, name: str):
        self.name = name
        self.extra_state = {}

    def damage(self, amount: int):
        self.extra_state["damage"] = True

player = Player("Ada")
Player.debug_name = lambda self: self.name.upper()
player.noclip = True
Player.damage = patched_damage

class Player:
    name: str
    extra_state: dict[str, bool]

    def damage(self, amount: i32):
        self.extra_state["damage"] = True

player = Player(name="Ada", extra_state={})

Player.debug_name = debug_name
# error: Player has no class member debug_name

player.noclip = True
# error: Player has no field noclip

Player.damage = patched_damage
# error: methods can't be replaced at runtime

from collections.abc import Callable, Mapping, Sequence

Parser = Callable[
    [Mapping[
        str,
        Sequence[Callable[[bytes], tuple[int, str | None]]],
    ]],
    list[tuple[str, int]],
]

type Parser = fn(
    dict[
        str,
        list[fn(array[u8]) -> tuple[i32, Option[str]]],
    ]
) -> list[tuple[str, i32]]

from collections.abc import Callable
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from engine.assets import AssetStore
    from engine.events import Event
    from engine.scene import Node, Scene

class Editor:
    scene: "Scene"
    selected: "Node | None"
    assets: "AssetStore"
    listeners: "dict[str, list[Callable[[Event], None]]]"

    def open_scene(
        self,
        scene: "Scene",
        selected: "Node | None",
    ) -> "dict[str, Node]":
        self.scene = scene
        self.selected = selected
        return scene.nodes

from engine.assets import AssetStore
from engine.events import Event
from engine.scene import Node, Scene

class Editor:
    scene: Scene
    selected: Option[Node]
    assets: AssetStore
    listeners: dict[str, list[fn(Event)]]

    def open_scene(
        self,
        scene: Scene,
        selected: Option[Node],
    ) -> dict[str, Node]:
        self.scene = scene
        self.selected = selected
        return scene.nodes

from cpp import thread

workers: list[std.thread] = []
for worker_id in range(worker_count):
    workers.append(std.thread(run_worker, worker_id))

Performance and memory use.

Dudu emits C++20 and uses the native optimizer. The generated program doesn't require a Python interpreter or Python objects. It can use normal inlining, autovectorization, SIMD intrinsics, and native CPU threads. Each case below shows the measured Python, Dudu, and handwritten C++ implementation.

def scalar_sum(n: int) -> int:
    total = 0
    for i in range(n):
        total += i * 3
    return total

def scalar_sum(n: i32) -> i64:
    total: i64 = 0
    for i in range(n):
        total += i64(i) * 3
    return total

int64_t scalar_sum(int32_t n) {
    int64_t total = 0;
    for (int32_t i = 0; i < n; ++i) {
        total += int64_t(i) * 3;
    }
    return total;
}

def list_accum(n: int) -> int:
    values: list[int] = []
    for i in range(n):
        values.append(i & 1023)

    total = 0
    for value in values:
        total += value
    return total

def list_accum(n: i32) -> i64:
    values: list[i32] = []
    for i in range(n):
        values.append(i & 1023)

    total: i64 = 0
    for value in values:
        total += i64(value)
    return total

int64_t list_accum(int32_t n) {
    std::vector<int32_t> values{};
    for (int32_t i = 0; i < n; ++i) {
        values.push_back(i & 1023);
    }
    int64_t total = 0;
    for (int32_t value : values) {
        total += int64_t(value);
    }
    return total;
}

class Particle:
    __slots__ = ("x", "y", "vx", "vy")

    def __init__(self, x, y, vx, vy):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy

particles: list[Particle] = []
for i in range(count):
    particles.append(Particle(
        float(i & 1023),
        float((i * 3) & 1023),
        0.25, -0.125,
    ))

for _ in range(steps):
    for particle in particles:
        particle.x += particle.vx
        particle.y += particle.vy

class Particle:
    x: f32
    y: f32
    vx: f32
    vy: f32

particles: list[Particle] = []
for i in range(count):
    particles.append(Particle(
        x=f32(i & 1023),
        y=f32((i * 3) & 1023),
        vx=0.25, vy=-0.125,
    ))

for _ in range(steps):
    for particle: &Particle in particles:
        particle.x += particle.vx
        particle.y += particle.vy

struct Particle {
    float x, y, vx, vy;
};

std::vector<Particle> particles;
for (int32_t i = 0; i < count; ++i) {
    particles.push_back(Particle{
        float(i & 1023),
        float((i * 3) & 1023),
        0.25F, -0.125F,
    });
}

for (int32_t step = 0; step < steps; ++step) {
    for (Particle& particle : particles) {
        particle.x += particle.vx;
        particle.y += particle.vy;
    }
}

def threaded_accum(workers: int, n: int):
    output = [0] * workers

    def worker(index: int):
        total = 0
        for i in range(n):
            total += i * 3
        output[index] = total

    threads = []
    for index in range(workers):
        thread = threading.Thread(
            target=worker, args=(index,)
        )
        threads.append(thread)
        thread.start()
    for thread in threads:
        thread.join()
    return sum(output)

from cpp import functional
from cpp import thread

def worker(index: i32, n: i32, out: &list[i64]):
    total: i64 = 0
    for i in range(n):
        total += i64(i) * 3
    out[index] = total

out: list[i64] = []
out.resize(worker_count)
threads: list[std.thread] = []
for index in range(worker_count):
    threads.append(std.thread(
        worker, index, n, std.ref(out)
    ))
for thread: &std.thread in threads:
    thread.join()

void worker(int32_t index, int32_t n,
            std::vector<int64_t>& out) {
    int64_t total = 0;
    for (int32_t i = 0; i < n; ++i) {
        total += int64_t(i) * 3;
    }
    out[index] = total;
}

std::vector<int64_t> out(worker_count);
std::vector<std::thread> threads;
for (int32_t index = 0;
     index < worker_count; ++index) {
    threads.emplace_back(
        worker, index, n, std::ref(out));
}
for (std::thread& thread : threads) {
    thread.join();
}

Other compilation targets.

Dudu emits ordinary C++. A target still needs a working C++ toolchain and appropriate libraries. The following targets are possible through existing C++ toolchains, but are not all validated release targets yet.

Less code golf.

I used to like these forms. I have worked on code where tools converted loops into comprehensions, then I converted them back to edit them, then converted them into comprehensions again before committing. Dudu uses ordinary declarations, functions, loops, and scopes instead.

List comprehension

names = [item.name for item in items if item.enabled]

names: list[str] = []
for item in items:
    if item.enabled:
        names.append(item.name)

Dict comprehension

scores = {player.id: player.score
          for player in players
          if player.connected}

scores: dict[PlayerId, i32] = {}
for player in players:
    if player.connected:
        scores[player.id] = player.score

Lambda

Lambda is anonymous-function syntax inherited from Lisp and jury-rigged into modern languages. Functions are first-class values in Dudu, so named function declarations cover callback use cases without adding a second function syntax.

button.on_click(
    lambda event: save_document(event.document)
)

def save_clicked(event: ClickEvent):
    save_document(event.document)

button.on_click(save_clicked)

Generator

def enabled_names(items: list[Item]):
    for item in items:
        if item.enabled:
            yield item.name

for name in enabled_names(items):
    print(name)

def visit_enabled_names(
    items: &const[list[Item]],
    visit: fn(&const[str]),
):
    for item: &const[Item] in items:
        if item.enabled:
            visit(item.name)

visit_enabled_names(items, print_name)

Ternary expression

label = "ready" if connected else "offline"

label: str
if connected:
    label = "ready"
else:
    label = "offline"

with

with lock:
    update_shared_state()

with open("state.bin", "wb") as output:
    output.write(data)

from cpp import mutex

def update_locked(lock: &std.mutex):
    guard = std.lock_guard[std.mutex](lock)
    update_shared_state()
    # guard unlocks when this scope ends

output = File("state.bin", "wb")
output.write(data)
# output closes when its scope ends

Some comparisons between C++ and Dudu.

struct Particle {
    Vec2 position;
    Vec2 velocity;
    float lifetime;
};

auto particle = Particle{
    .position = spawn_position,
    .velocity = random_velocity(),
    .lifetime = 2.0F,
};

class Particle:
    position: Vec2
    velocity: Vec2
    lifetime: f32

particle = Particle(
    position=spawn_position,
    velocity=random_velocity(),
    lifetime=2.0,
)

auto monitor = setup_monitor_rect();
auto window_size = make_16_9_half(monitor);
auto window = SDL_CreateWindow(
    "renderer", window_size.width, window_size.height, flags);
auto renderer = SDL_CreateRenderer(window, nullptr);
auto texture = SDL_CreateTexture(
    renderer, SDL_PIXELFORMAT_RGBA8888,
    SDL_TEXTUREACCESS_STREAMING, render_w, render_h);
auto format = SDL_GetPixelFormatDetails(
    SDL_PIXELFORMAT_RGBA8888);

monitor = setup_monitor_rect()
window_size = make_16_9_half(monitor)
window = SDL_CreateWindow(
    "renderer", window_size.width, window_size.height, flags,
)
renderer = SDL_CreateRenderer(window, None)
texture = SDL_CreateTexture(
    renderer, SDL_PIXELFORMAT_RGBA8888,
    SDL_TEXTUREACCESS_STREAMING, render_w, render_h,
)
format = SDL_GetPixelFormatDetails(
    SDL_PIXELFORMAT_RGBA8888
)

Vec2 operator+(const Vec2& other) const {
    return {x + other.x, y + other.y};
}

@operator("+")
def add(self, other: Vec2) -> Vec2:
    return Vec2(self.x + other.x, self.y + other.y)

self is an inferred reference to the current object. Larger inputs can spell &const[Vec2] explicitly to avoid a copy.

The editor shows inferred types, native definitions, documentation, references, and layout information. The compiler can emit the generated C++ for inspection.

Features taken from other languages.

Dudu includes payload enums, exhaustive matching, results, options, fixed-width scalar types, fixed-shape arrays, and GLSL-style swizzling.

Payload enums and exhaustive match

enum Event {
    Quit,
    KeyDown { key: i32 },
    MouseMove { x: i32, y: i32 },
}

fn score(event: Event) -> i32 {
    match event {
        Event::Quit => 0,
        Event::KeyDown { key } => key,
        Event::MouseMove { x, y } => x + y,
    }
}

enum Event:
    Quit

    KeyDown:
        key: i32

    MouseMove:
        x: i32
        y: i32

def score(event: Event) -> i32:
    match event:
        case Event.Quit:
            return 0
        case Event.KeyDown(key):
            return key
        case Event.MouseMove(x, y):
            return x + y

The compiler checks that every variant is handled and reports unreachable cases.

Result values

fn read_port(text: &str) -> Result<u16, ParseError> {
    text.parse::<u16>()
}

match read_port(input) {
    Ok(port) => start(port),
    Err(error) => report(error),
}

def read_port(text: &const[str]) -> Result[u16, ParseError]:
    return parse_port(text)

match read_port(input):
    case Ok(port):
        start(port)
    case Err(error):
        report(error)

Option[T] handles absence in the same style. C++ exceptions remain available for imported-library compatibility.

Fixed-shape arrays

using Matrix4 = std::array<
    std::array<float, 4>,
    4
>;

Matrix4 transform{};
transform[2][3] = 1.0F;

type Matrix4 = array[f32][4, 4]

transform: Matrix4
transform[2, 3] = 1.0

Array extents are part of the type. Numeric libraries can define Python-shaped slicing and advanced indexing through the normal indexing operators.

GLSL-style swizzling

vec4 position = vec4(1.0, 2.0, 3.0, 4.0);
vec2 xy = position.xy;
vec2 yx = position.yx;
vec2 xx = position.xx;
position.yx = vec2(8.0, 9.0);

position = Vec4(1.0, 2.0, 3.0, 4.0)
xy = position.xy
yx = position.yx
xx = position.xx
position.yx = Vec2(8.0, 9.0)

class Vec2:
    x: f32
    y: f32

class Vec4:
    x: f32
    y: f32
    z: f32
    w: f32

position = Vec4(1.0, 2.0, 3.0, 4.0)

xy = position.xy       # Vec2(1, 2)
yx = position.yx       # Vec2(2, 1)
xx = position.xx       # Vec2(1, 1)

position.yx = Vec2(8.0, 9.0)
# position is now Vec4(9, 8, 3, 4)

position.xx = Vec2(1.0, 2.0)
# error: swizzle assignment
# cannot repeat component: xx

class Color4:
    r: f32
    g: f32
    b: f32
    a: f32

bgra = color.bgra
solid_red = color.rrrr

class TexCoord4:
    s: f32
    t: f32
    p: f32
    q: f32

rotated = uv.tspq
corner = uv.qqqq

There is no special Vec4 compiler type and no swizzle decorator. Compatible xyzw, rgba, or stpq fields opt a Dudu or imported native vector type into the feature. Reads can repeat components. Writes can't.