Tiny Language Support

Beautiful VS Code support for Tiny, a lightweight programming language with a fast Go VM, bytecode, classes, std modules, and scripting-friendly syntax.

This extension adds syntax highlighting, IntelliSense, diagnostics, formatting, hover info, go-to-definition, and more for .tiny files.

---

Features

Syntax Highlighting

Tiny files get clean highlighting for:

• variables and constants
• functions
• classes and fields
• enums
• imports and exports
• strings and interpolated strings
• comments
• control flow
• operators
• std modules

import std "io";

class Counter {
    field value: number = 0;

    fn inc() {
        this.value++;
        return this.value;
    }
}

const counter = Counter();
io.println(counter.inc());

---

IntelliSense / Autocomplete

The extension provides autocomplete for:

• local variables
• functions
• function parameters
• class fields
• class methods
• this. inside classes
• imported namespaces
• std modules
• native type methods like arrays, strings, objects, tasks, and more

Example:

const items = [1, 2, 3];

items.
// shows: push, get, set, length, join, map, filter, clear...

Inside classes:

class Validator {
    field errors: array = [];

    fn reset() {
        this.
        // shows: errors, reset, ...
    }
}

---

Hover Information

Hover over symbols to see useful information:

• variable type
• function signature
• class fields and methods
• std module methods
• return types
• imported symbols

Example:

fn greet(name: string): string {
    return "Hello " + name;
}

Hovering greet shows its signature.

---

Diagnostics

The LSP reports common issues while editing:

• undefined variables
• undefined methods/properties
• invalid member access
• invalid imports
• parser errors
• type-related hints where possible

Example:

const user = User();

user.missingMethod();
// warning: undefined method or property

Tiny is dynamic, so the LSP tries to avoid annoying false warnings for loose objects and unknown types.

---

Formatting

Format Tiny documents directly from VS Code.

Supports formatting for:

• functions
• classes
• blocks
• if/else
• loops
• arrays and objects
• operators
• comments and strings safely

Run:

Format Document

or use your normal VS Code formatting shortcut.

---

Go to Definition

Jump to definitions for:

• variables
• functions
• classes
• class methods
• class fields
• imported symbols
• namespace members

Example:

import "models.tiny" as models;

const post = models.Post();

Go to definition on Post jumps to the exported class in models.tiny.

---

Signature Help

Function and method calls show parameter help while typing:

io.println(

---

Document Symbols

The extension exposes file symbols to VS Code’s outline panel:

• functions
• classes
• fields
• methods
• enums
• variables
• imports/namespaces

This makes bigger Tiny projects easier to navigate.

---

Supported Tiny Features

The extension understands many Tiny language features, including:

• let and const
• functions
• anonymous functions
• variadic parameters
• default parameters
• nullable parameters
• classes
• fields
• methods
• private/public members
• enums
• imports and exports
• std imports
• namespace imports
• arrays
• objects
• strings
• interpolated strings
• if, else, else if
• while
• for
• for in
• try/catch
• spawn
• task.await
• union type hints
• class type hints
• optional chaining

---

Example

import std "io";
import std "time";

enum Status { Draft, Published, Archived }

class Post {
    field title: string = "";
    field views: number = 0;
    field status = null;

    fn init(title: string) {
        this.title = title;
        this.status = Status.Draft;
    }

    fn publish() {
        this.status = Status.Published;
    }

    fn view() {
        this.views++;
    }

    fn summary() {
        return `${this.title} - ${this.views} views`;
    }
}

const post = Post("Hello Tiny");

post.publish();
post.view();

io.println(post.summary());
io.println(time.nowMs());

---

File Extension

Tiny files use:

.tiny

---

Requirements

You need the Tiny compiler installed and available to the extension.

If your extension starts the Tiny LSP server from a local executable, make sure the path is configured correctly.

---

Current Status

Tiny Language Support is still evolving with the language itself.

Some features may improve over time as Tiny’s parser, VM, std library, and type system grow.

---

Contributing

Contributions are welcome.

Good areas to help with:

• better highlighting
• more autocomplete cases
• formatter improvements
• diagnostics
• examples
• docs
• snippets
• themes/icons

---

License

MIT