Introduction

Byte is a lightweight interpreted scripting language designed for simplicity, educational use, and rapid prototyping. Its syntax allows for variables, functions, loops, conditionals, buttons, object interactions, and basic graphics operations easily with it's simple keywords and syntax. Byte is particularly suitable for creating small games or interactive scripts with minimal overhead. Note: Future updates may introduce new keywords or behavior, so older scripts may occasionally require adjustments.

Core Syntax Rules

• Scripts start with: STR — this signals the interpreter that the script is beginning.
• Function and loop blocks: Functions are closed with end and loops with -.
• Variables: Declare using VAR [name]. They are global unless inside a function.
• Case-sensitive: All commands and variable names must be correctly capitalized.
• Comments: Use // for full-line comments or =// for inline comments.
• Whitespace: Mostly ignored, but recommended for readability. Indentation does not affect execution.

Keywords & Their Uses

Below is a comprehensive list of keywords with their purpose and example usage:

Data Types

• Numbers: Integers or decimals; support standard arithmetic + - * /.
• Strings: Wrapped in quotes; concatenated with +.
• Booleans: true or false.
• Objects: Used with Spawn.New, SIPHON, raycast and movement commands.

Variables declared globally persist throughout the script; inside a function, they are local unless explicitly shared. Memory management is automatic, except const, which is immutable.

Control Flow

• Conditionals: IF / AND / NOT / THN / END — supports logical operators and nesting.
• Loops: -c + N = ... - — multi-line blocks or single-line loops.
• Functions: Defined with func and run via EXE or automatically via onStr.

Advanced Functions

• Change: Updates a variable at runtime; supports expressions.
• SIPHON: Temporarily marks a variable or object as "siphoned" for N seconds.
• Share: Exposes local variable globally or allows access outside current scope.
• addNum / dleNum: Operates on the most recently declared variable or first declared variable.
• do: Calls a function by name, either directly or via a variable reference.

Performance Tips

• Avoid deep nested loops; keep iterations minimal.
• Use WIT instead of busy-wait loops to reduce CPU load.
• Reuse functions and prefer local variables where possible for memory efficiency.
• Limit repeated SIPHON and Share operations inside loops.

API

!! IF YOU ARE USING BYTE FOR API, IT'S HERE !!

• Step 1: Open your browser console (right-click → Inspect → Console) and paste the following code to download byte.json:

fetch('https://bytedev.neocities.org/API/byte.json')
  .then(res => res.blob())
  .then(blob => {
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = 'byte.json';
    a.click();
  })
  .catch(err => console.error('Error fetching byte.json:', err));

If pasting is blocked, type allow pasting in the console first.

• Step 2: Place byte.json in your project folder, typically the root.
• Step 3: Access the API in JavaScript or Node.js:

Browser example:

fetch('./byte.json')
  .then(res => res.json())
  .then(data => console.log(data));

Node.js example:

const fs = require('fs');
const data = JSON.parse(fs.readFileSync('./byte.json', 'utf-8'));
console.log(data);

Math Operations

Math commands start with math. followed by the operation (Add, Sub, Mul, Div). Operands can be numeric literals or variables (using do for variable evaluation). Example:

STR
math.Add 1 + 4 =
math.Sub 7 - 2 =
math.Mul 2 * 4 =
math.Div 6 / 3 =

Output:

5
5
8
2

This illustrates Byte's support for arithmetic evaluation inline with script execution. Some answers may not be accurate since computers sometimes struggle with complex math equations. Think: decimals.

FAQ & Common Issues

• Unknown command: Check spelling and capitalization.
• Variable not defined: Declare it first with VAR or const.
• Infinite loop: Ensure -c + N uses a finite N.
• Buttons not working: Ensure onStr initializes them and the function exists.
• Make loops wait: Use WIT = seconds inside loops.
• Stop a loop conditionally: Use STO.
• Create a button: Use Button + "Label" EXE [Function] inside onStr.
• Detect/move objects: Use raycast, assign AT / TA / BT / TS for movement.

Examples

Counter Button

STR
VAR [Counter] ST

IncreaseCounter =
    Counter = Counter + 1
    RRI ("Counter: " + Counter)-
end

onStr =
    Button + "Click Me" EXE [IncreaseCounter]
end

Loop with Wait

-c + 3 =
    RRI("Iteration")-
    WIT = 0.5
-

SIPHON Example

SIPHON + 3
RRI ("Siphoned for 3s")-

Conditional Stop

-c + 10 =
    IF Counter = 5 THN STO END
-

Best Practices

• Always start with STR and properly close loops/functions.
• Use descriptive variable names and comments for readability.
• Keep scripts modular; test functions individually and avoid deep nesting.
• Use const for fixed values and STO for safe termination.
• Refactor regularly to remove redundancy and align with latest syntax.
• Update your old scripts when Byte updates more
• There will be no saving code in browser, use Visual Studio Code for saving, or use any IDE that isn't targeted onto 1 programming language.

Summary

Byte is a compact but versatile language, ideal for scripting, UI interactions, and basic game logic. This documentation covers everything from keywords, syntax, loops, buttons, advanced functions, math operations, and debugging tips. Use this as a reference for your Byte projects.

Questions or suggestions? Contact: bytedevinquiries@gmail.com