// 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 — ownership is simpler (move by default, compiler inserts 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 x86-64 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 (explicit memory in t0/t1, optional in t2)
  • - Different: no goroutines — explicit worker threads with channels

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