// coming from

You already know something like tape

Tape borrows ideas from many languages. Here's what translates and what's different.

Rust

Familiar ownership thinking, less ceremony

  • - No borrow checker — copy on assign, move on return, the compiler inserts the drops
  • - No generics — @tape {} comptime replaces monomorphization
  • - No traits — structural protocols (has .next()? it's iterable)

C

Same control, less footguns

  • - Same direct codegen to native (we emit the machine code ourselves)
  • - Same pointer arithmetic and manual memory in t0
  • - Better: tagged unions + match instead of raw unions + casts

Go

Similar simplicity, different tradeoffs

  • - Same: simple language, fast compilation, no generics philosophy
  • - Different: no GC by default (manual in t0, opt-in in t1, standard in t2)
  • - Different: no goroutines — explicit worker threads with channels (planned)

Java

Static typing without the VM

  • - No inheritance — structs plus methods, components compose via slots
  • - No generics — @tape {} emits the specialization, unboxed
  • - No exceptions — T or E declares the failure in the signature

Python

Quick to write, then compiled

  • - Same: locals infer their type, string interpolation, run a file directly
  • - Different: t2 relaxes the annotations, t1 makes them mandatory
  • - Different: errors are returned values, never raised exceptions

Qt / C++

Components without the framework

  • - Components with props/events/slots are language-level, not macro magic
  • - No MOC — the compiler understands components natively
  • - No signal/slot runtime overhead — events are typed function pointers

Vue / React

Same component model, compiled not interpreted

  • - Single-file components — #code + #view + #style in one .tape file
  • - Props, slots, events work the same conceptually
  • - No virtual DOM — static tree with targeted updates at dynamic points

Zig

Closest sibling — different priorities

  • - Same: comptime replaces generics, no hidden control flow
  • - Same: explicit allocators, no GC, manual memory
  • - Different: tape has a built-in component/UI model