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
- Android Google Play
- Web vanillagay.com
- iPhone App Store, coming soon
- Today
- Hey! Saw you're new in Barcelona. How are you finding it?
- ¿Tomamos un café mañana? Coffee tomorrow?
- Sure! 11 by the harbour?
- ¡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.
Play Investour
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.
Play Dutch
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
-
macOS & Linux
curl -fsSL https://raw.githubusercontent.com/berkayakin/kuana-editor/main/install.sh | sh - All platforms GitHub Releases
- Source code GitHub
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.
valandvar, data classes, string templates,?.and?:,whenand lambdas withit: what Kotlin and TypeScript developers already know. - No boilerplate. Oxie writes the derives, constructors,
DisplayandErrorimpls,&mut self,let mutandOk(...)for you. - Still a Cargo crate. Use anything on crates.io, mix
.rsand.oxifiles, and get completion and hover in any editor throughoxie lsp.
Get Oxie
-
macOS & Linux
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/oxie-lang/oxie/releases/latest/download/oxie-installer.sh | sh - Learn it A tour of Oxie
- Source code GitHub
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?andcatchreplace theif err != nilblocks. 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
gocommand.
Get Lyth
-
macOS & Linux
brew install lyth-lang/tap/lyth -
With Go 1.26+
go install github.com/lyth-lang/lyth/cmd/lyth@latest - Learn it Take the tour
- Source code GitHub
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.
- 2021 BKYMZ is founded
- Vanilla launches
- Investour launches on Steam
- 2026 Dutch launches on the web
- Kuana is released as open source
- Oxie is released as open source
- Lyth is released as open source
- Next Vanilla comes to iPhone