BKYMZ

An independent software studio, founded in 2021 and also known as Testchambr. We make the dating app Vanilla, the board game Investour, the card game Dutch, the code editor Kuana and the programming languages Oxie and Lyth.

See our products

Vanilla

A dating app for gay, bi and queer men. Meet guys nearby or anywhere in the world, chat in your own language with one-tap translation, and video call the people you click with.

Members worldwide
250K+
Downloads on Google Play
100K+
  • Chat requests. People ask before they can message you, so you only get the conversations you said yes to.
  • Stories and feed. Share photo and video stories that disappear after 24 hours.
  • Video calls. See if the spark is real before you meet.

Get Vanilla

Mateo 2 km away
  1. Today
  2. Hey! Saw you're new in Barcelona. How are you finding it?
  3. ¿Tomamos un café mañana? Coffee tomorrow?
  4. Sure! 11 by the harbour?
  5. ¡Perfecto! Nos vemos allí. Perfect! See you there.

Investour

A free, fast multiplayer property board game. Buy places, build houses and hotels, collect rent from your rivals and bet on what happens next. Matches finish in minutes, not hours.

Players per match
Up to 6
Steam reviews
85% positive
  • Cross-platform. Friends on Windows, macOS and Android play at the same table.
  • Ranked play. Start as a Novice and climb to Grandmaster on the global leaderboard.
  • Private matches. Invite your friends, or play against bots on your own.
An Investour match: four players around a board of city properties, with two dice in the middle

Dutch

A cunning memory card game you play online with friends. Everyone gets four face-down cards they can't look at. Swap your way to the lowest hand, remember what you've seen, and call Dutch before anyone else.

Players per table
2 to 6
Languages
8
  • No sign-up. Create a table, share the code, and your friends join straight from their browser.
  • Special cards. Jacks swap any two cards on the table, Queens let you peek, Aces hand a rival an extra card, and red Kings are worth nothing.
  • Match out of turn. Hold the same rank as the card just discarded? Throw it on top, but guess wrong and you take a penalty card.
A Dutch table for three players: each has four face-down cards, with the deck and the discard pile in the middle

Kuana

A fast, beautiful code editor for macOS, Windows and Linux, written in Rust and drawn by your GPU. JetBrains-style comfort at native speed. Free and open source, with no account and no telemetry.

Memory with a 540-file project open
130 MB
Built-in themes
50
  • Feels like home. Double Shift, Find Action and Alt+Enter work like in a JetBrains IDE, or switch to the VS Code, Sublime Text or Zed keymap. Vim mode is built in.
  • Runs Zed extensions. Zed's languages, themes and icon themes work as they are, sandboxed as WebAssembly.
  • Batteries included. Language servers, a debugger, a full Git UI, a terminal and a run button next to every test.

Get Kuana

The Kuana editor on macOS with a Rust project open: the file tree on the left and the code in the middle

Oxie

A programming language for the Rust ecosystem. You write a concise, familiar syntax and Oxie compiles it to plain Rust, so every crate works and your programs run exactly as fast as hand-written Rust.

Speed of hand-written Rust
1.00×
Rust compatible
100%
  • Familiar syntax. val and var, data classes, string templates, ?. and ?:, when and lambdas with it: what Kotlin and TypeScript developers already know.
  • No boilerplate. Oxie writes the derives, constructors, Display and Error impls, &mut self, let mut and Ok(...) for you.
  • Still a Cargo crate. Use anything on crates.io, mix .rs and .oxi files, and get completion and hover in any editor through oxie lsp.

Get Oxie

Eleven lines of Oxie and the 29 lines of Rust the compiler turns them into

account.rs generated, 29 lines

use std::fmt;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct Account {
    owner: String,
    balance: u64,
}

impl Account {
    fn new(owner: String, balance: u64) -> Self {
        Self { owner, balance }
    }

    fn deposit(&mut self, amount: u64) {
        self.balance += amount;
    }
}

impl fmt::Display for Account {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}: {}", self.owner, self.balance)
    }
}

fn main() {
    let mut account = Account::new(String::from("Ada"), 0);
    account.deposit(100);
    println!("{account}");
}

account.oxi you write, 11 lines

data class Account(owner: String, balance: u64 = 0) {
    fun deposit(amount: u64) { balance += amount }

    override fun toString() = "$owner: $balance"
}

fun main() {
    var account = Account("Ada")
    account.deposit(100)
    println("$account")
}

Lyth

A programming language that compiles to the Go you would write by hand, minus the boilerplate. Every Go package works as is, and programs run as fast as hand-written Go, because they are Go.

Shorter than the same Go
20%
Shorter in error-heavy code
37%
  • Errors in one character. throws, a postfix ? and catch replace the if err != nil blocks. Errors stay plain Go values, with no exceptions.
  • Nil checked for you. Nullable types like User?, with ?. and ?:. Using a value that may be nil without a check is a compile error, not a crash in production.
  • All of Go. Every Go package works under its Go names, Lyth packages are ordinary Go packages, and builds use the official go command.

Get Lyth

25 lines of Lyth and the 62 lines of Go the compiler turns them into

users.lyth.go generated, 62 lines

import (
  "errors"
  "fmt"
  "os"
  "strconv"
)

type User struct {
  ID    int64   `json:"id"`
  Name  string  `json:"name"`
  Email *string `json:"email"`
}

func find(id int64) (*User, error) {
  if id < 0 {
    return nil, errors.New("negative id " + strconv.FormatInt(id, 10))
  }
  if id == 0 {
    return nil, nil
  }
  return &User{ID: id, Name: "Ada", Email: nil}, nil
}

func describe(raw string) (string, error) {
  id, err := strconv.ParseInt(raw, 10, 64)
  if err != nil {
    return "", err
  }
  var user User
  v, err := find(id)
  if err != nil {
    return "", err
  }
  if v == nil {
    return "nobody", nil
  }
  user = *v
  var email string
  v2 := user.Email
  if v2 != nil {
    email = *v2
  } else {
    email = "no email"
  }
  return user.Name + " <" + email + ">", nil
}

func run() error {
  v, err := describe("1")
  if err != nil {
    return err
  }
  fmt.Println(v)
  v2, err := describe("x")
  if err != nil {
    v2 = "error: " + err.Error()
  }
  fmt.Println(v2)
  return nil
}

func main() {
  if err := run(); err != nil {
    fmt.Fprintln(os.Stderr, "error:", err)
    os.Exit(1)
  }
}

users.lyth you write, 25 lines

import "errors"

struct User {       // json tags: "id", "name", "email"
    ID: int64
    Name: string
    Email: string?  // *string in Go, null in JSON
}

func find(id: int64): User? throws {  // Go: (*User, error)
    if id < 0 {
        throw errors.New("negative id ${id}")
    }
    if id == 0 {
        return null  // absent is a value, not an error
    }
    return User(ID = id, Name = "Ada", Email = null)
}

func describe(raw: string): string throws {
    id := raw.toInt64()?  // ? propagates the parse error
    user := find(id)? ?: return "nobody"
    email := user.Email ?: "no email"
    return "${user.Name} <${email}>"
}

func main() throws {
    println(describe("1")?)
    println(describe("x") catch (err) { "error: ${err}" })
}

About the studio

BKYMZ is also known as Testchambr. Same studio, same team, two names.

BKYMZ is a small, independent software studio. We design, build and run our own products from start to finish: mobile apps, web apps, online multiplayer games and developer tools, including the servers behind them.

Our products are live on Android, the web, Windows, macOS and Linux. Vanilla for iPhone is next.

  1. 2021 BKYMZ is founded
  2. Vanilla launches
  3. Investour launches on Steam
  4. 2026 Dutch launches on the web
  5. Kuana is released as open source
  6. Oxie is released as open source
  7. Lyth is released as open source