Official documentation for the Starlight programming language.
Starlight Programming Language
Starlight is a lightweight, modern scripting language designed for server-side scripting, CLI tools, and automation. It focuses on simplicity, readable syntax, and practical features for everyday programming. starlight-cli was officially released on December 14 2025.
Features
Simple and expressive syntax
Built-in CLI support
Server-side scripting friendly
Dynamic typing
First-class functions
Async / await support
Array and object utilities
Clean and readable error messages
Designed for learning and productivity
Installation
Install the Starlight CLI via npm:
npm install -g starlight-cli
Verify installation:
starlight --version
Running a Program
Create a file:
program.sl
Run it:
starlight program.sl
Example
let nums = range(0, 12, 2);
sldeploy nums;
if (len(nums) > 5) {
sldeploy "Array has more than 5 elements";
}
Output:
[ 2, 4, 6, 8, 10 ]
Array has more than 5 elements
Documentation
Full documentation is organized in the docs/ folder:
Name: Dominex Macedon
Date of Birth: March 21, 2006 (the same day as the first tweet)Mother: Daw Thet Thet Maw
Father: U Kyaw Moe
Early Inspiration
From an early age, I was fascinated by technology and problem-solving. My journey started with a simple goal: to make my father's job easier. Observing his work, I realized that customers often had to meet him in person to submit items, which was time-consuming. I wanted to create a solution that would allow customers to communicate and submit requests without physically visiting him.
This led me to develop a local chat system using MySQL, PHP, HTML, and CSS. The project was small but significant. I immediately understood that if a group of people could contact a single person, I could build a one-to-one chat interface. I implemented it, and it worked, marking my first success in building functional communication systems.
Web Development and GitHub
After creating the local chat system, I expanded my skills into web development. Using GitHub, I hosted projects and began experimenting with website creation and deployment. These early experiences helped me understand version control, collaboration, and project management in real-world software development.
Android Development: Falcon S
Later, I ventured into Android development and built a messaging app called Falcon S. This project used Android Studio, Firebase Auth, Realtime DB, Firestore, and Storage. The journey was challenging:
Dealing with long Gradle builds
Correctly adding google-services.json, a notoriously difficult part of Android development
Generating keystores and ensuring version codes matched
Through persistence, I successfully built the app, gaining deep experience in mobile application architecture, authentication, and real-time data management.
Desktop and Video Call Applications
To expand communication tools, I developed a video call room similar to Zoom:
Desktop: using Electron
Android app: using WebView
Signaling server: using Supabase
This project tested my ability to integrate cross-platform systems and manage real-time communication at scale.
Rendering Engine and React Native
Next, I attempted to create a rendering engine to render views directly from JSON. Though this project ultimately failed, it taught me valuable lessons about design systems, parsing, and dynamic UI rendering.
Afterwards, I moved to React Native and Expo, successfully rebuilding a messaging app with a CSS-like stylesheet design. This solidified my understanding of cross-platform mobile development and modern UI frameworks.
Starlight Programming Language
Finally, my experiences led me to develop the Starlight Programming Language.
Starlight is based on the rendering engine concept I had explored earlier, combining ideas from my web, mobile, and desktop projects to create a language that is flexible, interactive, and user-friendly.
My work with Starlight continues to evolve, reflecting my passion for communication systems, rendering engines, and innovative programming tools.
Summary
Throughout my journey:
I have built local chat systems, websites, Android apps, and desktop apps
I have faced and solved challenges in authentication, real-time databases, keystores, Gradle builds, signaling servers, and UI rendering
I have learned that persistence, experimentation, and understanding user needs are the keys to successful development
I am Dominex Macedon, a developer, innovator, and creator, dedicated to building tools that make communication seamless and intuitive.
Introduction to Starlight
Starlight is a high-level scripting language designed to be simple, expressive, and versatile. It combines the flexibility of dynamic typing with familiar programming structures.
Basic Principles
Everything is a value: numbers, strings, booleans, arrays, objects, functions, and more.
Variables are declared with let.
Statements end automatically; no semicolons are required.
Functions are first-class citizens and can be assigned to variables or stored in objects.
Starlight supports asynchronous operations like fetch and sleep.
Declaring Variables
Use let to declare a variable:
let name = "Alice"
let age = 25
let isStudent = true
Variables can hold any type of value, and the type can change dynamically:
let data = 10
data = "Now I'm a string"
Data Types
Starlight has several core types:
Numbers: 42, 3.14, -7
Strings: "Hello, world!"
Booleans: true, false
Arrays: [1, 2, 3], [ "a", "b" ]
Objects: { "key": "value", "num": 10 }
Functions: (x) => x * 2 or named function declarations
Null/None: null (no value)
Operators
Arithmetic: +, -, *, /, %
Comparison: ==, !=, <, <=, >, >=
Logical: and, or, not, ?? (nullish coalescing)
Assignment: =, +=, -=, *=, /=, %=
Control Flow
Conditional statements:
if age >= 18 {
let status = "Adult"
} else {
let status = "Minor"
}
Loops:
for let i = 0; i < 5; i++ {
# do something
}
let numbers = [1, 2, 3]
for num in numbers {
# iterate over array
}
while loops:
let count = 0
while count < 5 {
count += 1
}
Functions
Functions can be declared or assigned to variables:
let greet = (name) => "Hello " + name
let result = greet("Alice") # "Hello Alice"
Named function declaration:
define sayHi(name) {
"Hi " + name
}
Built-in Utilities
print(value) — output to console
len(value) — get length of array, string, or object
keys(obj) — get object keys
values(obj) — get object values
map(array, fn) — transform array
filter(array, fn) — filter array
reduce(array, fn, initial) — reduce array to a single value
ask(prompt) — get user input
sleep(ms) — pause execution
Starlight is designed to be readable, flexible, and powerful, while keeping syntax simple and natural.
getting started with starlight
starlight is a simple programming language designed to be easy to learn and fun to use.
running starlight
to run a file, use:
starlight filename.sl
to view a markdown file:
starlight filename.md
basic syntax
variables
let name = "alice"
let age = 16
let is_student = true
sldeploy name
sldeploy age
sldeploy is_student
data types
starlight supports:
strings: "hello"
numbers: 123, 3.14
booleans: true, false
arrays: [1, 2, 3]
objects: { key: "value" }
functions: func hello() { ... }
operators
let a = 10
let b = 5
sldeploy a + b
sldeploy a - b
sldeploy a * b
sldeploy a / b
sldeploy a % b
let t = true
let f = false
control flow
# if statement
if a > b {
sldeploy "a is greater"
} else {
sldeploy "b is greater or equal"
}
# while loop
let i = 0
while i < 3 {
sldeploy i
i += 1
}
# for loop
for let j = 0; j < 3; j += 1 {
sldeploy j
}
functions
func greet(name) {
sldeploy "hello " + name
}
greet("bob")
# arrow functions
let square = (x) => x * x
sldeploy square(5)
async / await
func getData(url) async {
let res = await fetch(url)
let data = await res.json()
return data
}
let info = await getData("https://jsonplaceholder.typicode.com/todos/1")
sldeploy info
sldeploy
use sldeploy to output values:
let message = "hello world"
sldeploy message
it can display numbers, strings, booleans, arrays, objects, and functions.
installation
this guide will help you get starlight up and running on your system.
requirements
node.js v18 or higher
npm (comes with node.js)
a terminal or command prompt
installing via npm (recommended)
to install starlight globally so you can run it from anywhere:
npm install -g starlight-cli@latest
after installation, check the version:
starlight --version
you should see something like:
starlight cli v1.1.7
developed by macedon
running starlight
once installed, you can run a starlight file like this:
starlight myprogram.sl
or view a markdown file directly:
starlight guide.md
uninstalling
if you ever need to remove starlight:
npm uninstall -g starlight-cli
Syntax Overview
This is a quick reference for the core syntax and constructs of your language.
1. Variables
Declaration
let x = 10;
let name = "Alice";
let declares a new variable.
Variables must be initialized.
Definition (global or constant-like)
define PI = 3.14159;
define greeting = "Hello!";
define creates a variable that persists globally.
2. Data Types
Numbers: 123, 3.14
Strings: "Hello", 'World'
Booleans: true, false
Null: null
Arrays: [1, 2, 3]
Objects: { key: "value", num: 42 }
3. Operators
Arithmetic
a + b
a - b
a * b
a / b
a % b
Assignment
x = 5;
x += 3; // x = x + 3
x -= 2;
x *= 2;
x /= 4;
x %= 2;
Comparison
a == b
a != b
a < b
a <= b
a > b
a >= b
Logical
a && b // AND
a || b // OR
a ?? b // Nullish coalescing
!a // NOT
4. Control Flow
If / Else
if (x > 0) {
sldeploy("Positive");
} else if (x < 0) {
sldeploy("Negative");
} else {
sldeploy("Zero");
}
While Loop
while (x < 5) {
sldeploy(x);
x += 1;
}
For Loop
for (let i = 0; i < 5; i += 1) {
sldeploy(i);
}
For-In Loop
for (let key in obj) {
sldeploy(key);
}
Do-Track (try-catch-like)
do {
sldeploy(10 / 0);
} track {
sldeploy(error); // error contains the exception
}
5. Functions
Regular Function
func add(a, b) {
return a + b;
}
sldeploy(add(2, 3)); // 5
returns number, string, array, object, function, or boolean.
tips
starlight is dynamically typed.
you can mix data types in arrays and objects.
use sldeploy for output, len() for array or string length.
all standard operations follow javascript-like behavior.
starlight control flow
starlight provides standard control flow statements like if, else, while, for, for-in, break, continue, and custom start/race/do and track for advanced flow control.
if / else
let x = 10
if x > 5 {
sldeploy "x is greater than 5"
} else {
sldeploy "x is 5 or less"
}
if requires a boolean condition.
else is optional.
conditions must evaluate to true/false.
while
let count = 0
while count < 3 {
sldeploy count
count += 1
}
loops run while condition is true.
use break to exit early, continue to skip to next iteration.
for
for let i = 0; i < 3; i += 1 {
sldeploy i
}
classic for loop with initializer, test, and update.
supports break and continue.
for-in
let arr = [10, 20, 30]
for val in arr {
sldeploy val
}
let obj = {a: 1, b: 2}
for key in obj {
sldeploy key
}
iterates over arrays or object keys.
val or key is dynamically assigned each iteration.
break / continue
let i = 0
while true {
i += 1
if i == 3 {
break
}
if i == 1 {
continue
}
sldeploy i
}
break inside a race stops executing further races.
doTrack
do {
let x = 10 / 0
} track {
sldeploy "error caught"
}
tips
loops and conditional bodies can have multiple statements.
you can nest any control flow statements.
sldeploy is used for output instead of print.
start / race / do and track are unique to starlight for choice and error handling.
# functions in starlight
# defining a function
func greet(name) {
sldeploy "hello " + name
}
# calling a function
greet("alice")
# function returning a value
func add(a, b) {
return a + b
}
let sum = add(5, 7)
sldeploy sum
# arrow functions (inline)
let multiply = (x, y) => x * y
sldeploy multiply(3, 4)
# arrow function with block
let divide = (a, b) => {
if b == 0 {
return "cannot divide by zero"
}
return a / b
}
sldeploy divide(10, 2)
sldeploy divide(10, 0)
# functions can be assigned to variables
let fn = greet
fn("bob")
# functions can be passed as arguments
func applyFn(fn, value) {
return fn(value)
}
let result = applyFn((x) => x * 2, 8)
sldeploy result
# async functions
func asyncFetch(url) async {
let response = await fetch(url)
let data = await response.json()
return data
}
# calling async function
let data = await asyncFetch("https://jsonplaceholder.typicode.com/todos/1")
sldeploy data
✅ key points:
func name(params) { ... } defines a function
return sends a value back
arrow functions (params) => expr or (params) => { ... } are supported
functions are first-class: can be stored in variables, passed around
async functions support await for promises or async tasks
sldeploy is used for output instead of print
Arrays in SL
Arrays in SL are ordered collections of values. They can contain any type, including numbers, strings, booleans, objects, other arrays, and even functions.
1. Creating Arrays
let nums = [1, 2, 3, 4, 5];
let names = ["Alice", "Bob", "Charlie"];
let mixed = [1, "two", true, null];
let nested = [[1, 2], [3, 4]];
2. Accessing Elements
Array elements are accessed using zero-based indices:
Arrays can grow dynamically by assigning to new indices:
nums[5] = 6;
sldeploy nums; # [42, 2, 3, 4, 5, 6]
4. Array Operations
SL supports iteration and higher-order functions:
let nums = [1, 2, 3, 4];
# Map: apply a function to each element
let squared = await map(nums, (x) => x * x);
sldeploy squared; # [1, 4, 9, 16]
# Filter: select elements
let evens = await filter(nums, (x) => x % 2 == 0);
sldeploy evens; # [2, 4]
# Reduce: accumulate values
let sum = await reduce(nums, (a, b) => a + b, 0);
sldeploy sum; # 10
5. Iterating Over Arrays
Using for loops
for (let i = 0; i < nums.length; i++) {
sldeploy nums[i];
}
Using for-in loops
for n in nums {
sldeploy n;
}
6. Built-in Functions for Arrays
len(array) — returns the length of the array:
sldeploy len(nums); # 4
map(array, fn) — returns a new array with each element transformed by fn.
filter(array, fn) — returns a new array containing elements where fn returns true.
reduce(array, fn, initial) — reduces the array to a single value using fn.
7. Combining Arrays
Arrays can be nested or concatenated manually:
let a = [1, 2];
let b = [3, 4];
let c = [a[0], a[1], b[0], b[1]];
sldeploy c; # [1, 2, 3, 4]
8. Summary
Arrays are zero-indexed.
Can contain any value type, including other arrays.
Support dynamic assignment, iteration, and higher-order functions like map, filter, reduce.
Use len() to get the number of elements.
Access out-of-bounds indices safely: returns undefined.
Objects in Your Language
Objects are collections of key-value pairs. They are similar to dictionaries or maps in other languages. Keys can be strings, numbers, or expressions, and values can be any type, including other objects or functions.
Creating Objects
Objects are created using let with curly braces {}:
Keys must be unique within an object. Values can be literals, arrays, functions, or even other objects.
Accessing Properties
Properties of an object can be accessed using dot notation or bracket notation:
let name = myObj.name
let age = myObj["age"]
You can also assign new values to existing properties:
myObj.age = 26
myObj["isStudent"] = false
New properties can be added dynamically:
myObj.grade = "A"
Nested Objects
Objects can contain other objects:
let person = {
"name": "Bob",
"address": {
"city": "New York",
"zip": "10001"
}
}
let city = person.address.city
Iterating Over Objects
You can iterate over objects using a for-in loop. This iterates over the keys:
for key in person {
let value = person[key]
}
You can also use built-in functions:
let keysList = keys(person) # ["name", "address"]
let valuesList = values(person) # ["Bob", { "city": "New York", "zip": "10001" }]
Object Methods
Objects can hold functions as values:
let calculator = {
"add": (a, b) => a + b,
"subtract": (a, b) => a - b
}
let sum = calculator.add(5, 3) # 8
let difference = calculator["subtract"](10, 4) # 6
Functions inside objects behave like normal functions but can also access the object if this is used.
Summary
Objects store key-value pairs.
Keys can be accessed via dot . or bracket [].
Objects can be nested and hold any type of value.
New properties can be added dynamically.
Iterate over objects with for-in or use keys and values.
Objects can contain functions as methods.
Modules in Starlight
Modules in Starlight allow you to organize code into separate files and reuse functionality across programs. They help keep your code clean, maintainable, and modular.
Importing Modules
Use the import statement to include another module in your program. You can import specific exports, the default export, or the entire module as a namespace.
Default Import
import fs from "./fileUtils.sl"
let content = fs.readFile("data.txt")
Named Import
import { readFile, writeFile } from "./fileUtils.sl"
let content = readFile("data.txt")
writeFile("output.txt", content)
Namespace Import
import * as fs from "./fileUtils.sl"
let content = fs.readFile("data.txt")
Exporting from a Module
In Starlight, everything defined in a file can be exported and used in other modules.
Example: Exporting Named Functions
define greet(name) {
"Hello " + name
}
define farewell(name) {
"Goodbye " + name
}
You can then import these functions using a named import:
import { greet, farewell } from "./messages.sl"
let msg = greet("Alice") # "Hello Alice"
let bye = farewell("Bob") # "Goodbye Bob"
Default Export
To export the entire module as a default:
let defaultExport = {
greet: greet,
farewell: farewell
}
And import it like this:
import messages from "./messages.sl"
let msg = messages.greet("Alice")
Importing External Libraries
Starlight can import Node.js modules or packages installed via npm:
import fs from "fs"
let data = fs.readFileSync("data.txt", "utf-8")
If a module cannot be found, Starlight will throw a RuntimeError with a suggestion if a similar name exists.
Module Scope
Each module has its own environment.
Variables and functions defined inside a module are not global unless explicitly exported.
This avoids conflicts and allows safe reuse of code.
Tips
Use named imports for clarity.
Use default exports for a module that mainly provides one object or function.
Keep modules small and focused on a single task.
Modules in Starlight make it easy to split large programs into manageable pieces while maintaining clean and reusable code.
async / await in Starlight
your language supports asynchronous programming using async functions and the await keyword. this allows you to write non-blocking code that reads like normal synchronous code.
declaring async functions
use the async func syntax to define an asynchronous function:
async func fetchdata(url) {
let response = await fetch(url);
let data = await response.json();
return data;
}
async func marks the function as asynchronous.
inside an async function, you can use await to pause execution until a promise-like operation completes.
returning a value from an async function automatically wraps it as a "resolved async result".
using await
await can be used with any async operation:
async func main() {
let user = await get('https://api.example.com/user/1');
sldeploy user;
}
main(); // calling an async function
await can only be used inside async functions.
execution pauses at await until the operation resolves.
the resolved value is returned and can be stored in a variable.
error handling with do…track
use do…track to catch errors from async operations:
async func loaddata() {
do {
let data = await fetch('https://api.example.com/data');
sldeploy await data.json();
} track {
sldeploy 'an error occurred:', error;
}
}
do contains the code that might fail.
track handles errors; the error variable holds the exception.
awaiting multiple async calls
you can run multiple async calls sequentially:
async func process() {
let a = await fetch('https://api.example.com/a');
let b = await fetch('https://api.example.com/b');
sldeploy [await a.json(), await b.json()];
}
or process arrays asynchronously:
async func processusers(users) {
let results = await map(users, async (u) => {
let res = await fetch(`https://api.example.com/user/${u.id}`);
return await res.json();
});
sldeploy results;
}
map, filter, and reduce are fully async-aware.
always await async callbacks to maintain proper sequence.
async arrow functions
async arrow functions work with await:
let fetchuser = async (id) => {
let response = await fetch(`https://api.example.com/user/${id}`);
return await response.json();
};
async func run() {
let user = await fetchuser(1);
sldeploy user;
}
run();
loops with async/await
you can use async functions inside loops:
async func loopfetch(users) {
for let u in users {
let data = await fetch(`https://api.example.com/user/${u}`);
sldeploy await data.json();
}
}
or using for…in over objects:
async func objloop(obj) {
for let key in obj {
let val = await obj[key];
sldeploy key, val;
}
}
sleep and delay
you can pause execution asynchronously:
async func countdown(n) {
for let i = n; i > 0; i-- {
sldeploy i;
await sleep(1000); // pause 1 second
}
sldeploy 'done!';
}
calling async functions
you can call async functions from other async functions using await.
calling an async function without await gives a "function object" (like a promise).
async func main() {
let data = await fetchdata('https://api.example.com');
sldeploy data;
}
main();
async with error handling in loops
you can combine loops, async, and do…track:
async func safefetch(users) {
for let u in users {
do {
let res = await fetch(`https://api.example.com/user/${u}`);
sldeploy await res.json();
} track {
sldeploy 'failed to fetch user', u, ':', error;
}
}
}
summary table
feature
syntax example
notes
async function
async func name(params) { … }
use await inside
await expression
let x = await asynccall()
only inside async
async arrow function
let fn = async (params) => …
can be single-expression or block
error handling
do { … } track { … }
error variable holds exception
async loops
for let x in array { await … }
handles async correctly
async utilities
map, filter, reduce
fully async-aware
sleep / delay
await sleep(ms)
pauses execution asynchronously
starlight cli guide
starlight comes with a command line interface (cli) to run code, open learning guides, and work interactively.
installation
make sure you have node.js installed.
clone or download starlight.
open a terminal in the starlight folder.
usage
starlight <file.sl> # run a starlight source file
starlight <file.md> # view a markdown file directly in browser
starlight --version # show cli version
starlight --help # show help
starlight --learn # open learning guide
starlight --writedirectly # interactive editor mode
options
-v or --version
show starlight cli version.
--help
display all available commands and usage.
--learn
opens the official starlight learning guide in your browser.
--writedirectly
opens an interactive editor for writing starlight code directly in the terminal.
running files
to run a .sl file:
starlight myscript.sl
to view a markdown file directly:
starlight guide.md
markdown files are rendered as html in your default browser.
interactive editor (--writedirectly)
type code directly in the terminal.
use :run to execute the code.
syntax is highlighted as you type.
after execution, you can choose to save the code.
example
let x = 5
let y = 10
sldeploy x + y # outputs 15
after typing :run, your code is evaluated immediately.
saved files must be inside an existing folder.
saving code from interactive mode
enter folder path when prompted.
enter file name. .sl extension is added automatically if missing.
your code is saved and can be run later using starlight <file.sl>.
error handling
syntax errors in parser stop execution without showing node.js stack trace.
runtime errors show the message with line and column info.
unexpected errors are also caught and displayed safely.
cli workflow summary
command
action
starlight <file.sl>
run a starlight source file
starlight <file.md>
view a markdown file directly in browser
starlight --version
show cli version
starlight --help
show this help guide
starlight --learn
open learning guide in browser
starlight --writedirectly
interactive editor with immediate evaluation and optional save
additional features
syntax highlighting in interactive mode.
temporary files automatically cleaned up after execution.
markdown files render beautifully in dark theme html.
cross-platform support for opening files and urls.
starlight-math
A lightweight math utility library for JavaScript and Starlight, providing constants, functions, and basic vector/matrix operations.
Starlight requires sldeploy() instead of print() for output.
When passing object parameters in Starlight, always use string keys if required by functions.
starlight-fs
A simple file system utility for JavaScript and Starlight, providing convenient methods for reading, writing, copying, deleting files and directories, as well as path utilities.
All functions are synchronous, except timers which use setInterval.
Use sldeploy() in Starlight for output instead of console.log().
sleep blocks the main thread. For async/non-blocking delays, consider using await sleepAsync(ms) (you could add a Promise-based sleep).
Starlight Color
starlight-color is a simple library for styling console text using ANSI escape codes. You can apply colors, background colors, and text styles like bold, underline, italic, and more.
Installation
npm install starlight-color@latest
Import
import { colors, bgColors, styles, style } from 'starlight-color';
The import line is the same in both JavaScript and Starlight.
style(text, {
color, // text color
bg, // background color
bold, dim, italic, underline, inverse, hidden, strike,
fg256, bg256 // 256-color support
})
Notes
In JavaScript, use console.log() to print styled text.
In Starlight, use sldeploy() for output.
You can combine multiple styles and colors using style().
Supports both named colors and 256-color mode.
starlight-txt-to-pdf
A utility to convert TXT files to PDF with text formatting, headers, footers, colors, bold/italic styles, and image embedding. Works in both JavaScript and Starlight.
Automatic page breaks when text exceeds page height.
Default page size: A4 (595 × 842 points).
Usage in Starlight
import { txtToPdf } from "starlight-txt-to-pdf";
await txtToPdf("letter.txt", "letter.pdf", { header: "My PDF Document 💌" });
sldeploy("PDF generated: letter.pdf");
Example TXT content with formatting:
# My Love Letter 💖
[color:red][b]Dear Alice,[/b][/color]
I hope this letter finds you well.
## Memories
[i]Remember the day we first met?[/i]
[img:heart.png,x=200,y=500,w=100,h=100]
Text colors, bold, italic, and headers will render correctly in PDF.
Images can be positioned anywhere using the [img:...] tag.
Use [pos:x,y]Text[/pos] for custom coordinates.
Notes
The function is asynchronous. Use await in Starlight or JS.
Default header text is "Love Letter 💖" if none is provided.
Page dimensions and margins can be adjusted inside the function if needed.
wiki-starlight-api
A simple Wikipedia API wrapper for fetching search results, summaries, full content, images, categories, and languages. Works in JavaScript and Starlight.
Installation
Install via npm:
npm install wiki-starlight-api@latest
Import
For both JavaScript and Starlight:
import * as wiki from "wiki-starlight-api";
Usage in JavaScript
import * as wiki from "wiki-starlight-api";
(async () => {
// Search articles
const results = await wiki.search("JavaScript", 5);
console.log("Search results:", results);
// Get summary of an article
const jsSummary = await wiki.summary("JavaScript");
console.log(jsSummary);
// Get full page content
const jsPage = await wiki.page("JavaScript");
console.log(jsPage.content);
// Get a random article
const randomArticle = await wiki.random();
console.log(randomArticle);
// Get article languages
const langs = await wiki.languages("JavaScript");
console.log("Available languages:", langs);
// Get article images
const imgs = await wiki.images("JavaScript");
console.log("Images:", imgs);
// Get article categories
const cats = await wiki.categories("JavaScript");
console.log("Categories:", cats);
// Search and get summaries
const summaries = await wiki.searchAndSummary("Python", 3);
console.log(summaries);
})();
Usage in Starlight
import * as wiki from "wiki-starlight-api";
// Search articles
const results = await wiki.search("JavaScript", 5);
sldeploy("Search results:\n" + results);
// Get summary
const jsSummary = await wiki.summary("JavaScript");
sldeploy("JavaScript summary:\n" + jsSummary.extract);
// Get full page content
const jsPage = await wiki.page("JavaScript");
sldeploy(jsPage.content);
// Get random article
const randomArticle = await wiki.random();
sldeploy("Random article:\n" + randomArticle.title + "\n" + randomArticle.extract);
// Get article languages
const langs = await wiki.languages("JavaScript");
sldeploy("Languages: " + langs.map(l => l.lang + " → " + l.title).join(", "));
// Get images
const imgs = await wiki.images("JavaScript");
sldeploy("Images: " + imgs.join(", "));
// Get categories
const cats = await wiki.categories("JavaScript");
sldeploy("Categories: " + cats.join(", "));
// Search and get summaries
const summaries = await wiki.searchAndSummary("Python", 3);
summaries.forEach(s => sldeploy(s.title + ": " + s.extract));
Features
search(query, limit): Search Wikipedia articles.
summary(title): Get article summary (intro).
page(title): Get full article content as plain text.
random(): Get a random article.
languages(title): Get available translations for an article.
images(title): Get images used in an article (PNG, JPG, JPEG, SVG, GIF).
categories(title): Get categories of an article.
searchAndSummary(query, limit): Search and return summaries for results.
Notes
All functions are asynchronous, so use await in Starlight or JavaScript.
Fetches data directly from Wikipedia’s REST API or MediaWiki API.
Designed for simplicity and quick access to article data.
Language Specification
1. Introduction
This language is a JavaScript-inspired scripting language with custom keywords and syntax for tasks like asynchronous functions, tracking, deployments (sldeploy), and race conditions (start ... race).
It supports:
Variables and constants
Functions (normal and async)
Control flow (if, while, for, do...track, start...race)
Name: Dominex Macedon
Date of Birth: March 21, 2006 (the same day as the first tweet)
Mother: Daw Thet Thet Maw
Father: U Kyaw Moe