steel-lang-2 1.0.0

package/LICENSE

@@ -0,0 +1,11 @@
+MIT License
+
+Copyright (c) 2026 theworker02
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE

package/README.md

@@ -0,0 +1,119 @@
+[![npm](https://img.shields.io/npm/v/steel-lang-2)](https://www.npmjs.com/package/steel-lang-2)
+
+Steel is a simple, readable programming language designed to be easy to learn and intuitive to use.
+
+It focuses on clean syntax, minimal complexity, and fast execution through a custom JavaScript interpreter.
+
+## Install
+
+```bash
+npm install steel-lang-2
+```
+
+
+
+
+
+ Features:
+• 🧠 Human-readable syntax
+• ⚡ Lightweight interpreter (Node.js)
+• 🧱 Simple variable system
+• 🔁 Control flow (if statements, loops)
+• 💬 Built-in output (say)
+• 🎨 VS Code syntax highlighting support
+• 🔧 Easy to extend and modify
+
+
+
+
+Project Structure:
+
+steel-lang/
+├── src/ # Language engine
+│ ├── lexer.js
+│ ├── parser.js
+│ ├── interpreter.js
+│ ├── environment.js
+│ └── index.js
+├── examples/ # Example programs
+│ ├── hello.steel
+│ ├── logic.steel
+│ └── variables.steel
+├── stl/ # VS Code extension
+│ ├── syntaxes/
+│ ├── icons/
+│ └── package.json
+└── README.md
+
+
+
+
+
+🚀 Getting Started
+
+Clone the repository
+
+1. git clone https://github.com/theworker02/steel-lang.git
+
+2. cd steel-lang
+
+
+
+Run a Steel program
+
+3. "node src/index.js examples/hello.steel"
+
+
+🧪 Example:
+
+set x to 10
+
+if x > 5 then
+say "Steel is working!"
+end
+
+
+https://steel-lang.base44.app
+
+
+🧩 VS Code Extension:
+
+Steel includes a custom VS Code extension for syntax highlighting.
+
+Run locally: “cd stl”
+
+Then open the folder in VS code and press: F5
+
+
+🎯 Goals:
+
+• Keep syntax simple and readable
+• Build a fully custom language ecosystem
+• Add functions, modules, and advanced features
+• Expand tooling (CLI, debugger, autocomplete)
+
+
+https://steel-lang.base44.app
+
+
+🛠️ Future Plans:
+
+• CLI command (steel run file.steel)
+• Error handling improvements
+• Function system
+• Package manager (maybe 👀)
+• Full VS Code integration (IntelliSense)
+
+
+🤝 Contributing:
+
+Pull requests are welcome. This project is actively evolving and is considered to me still a work in progress. A lot has to be done honestly.
+
+License: MIT License
+
+Author: theworker02
+
+⚙️ Status:
+
+🚧 Early Development/Work in progress, but fully functional
+

package/package.json

@@ -0,0 +1,25 @@
+{
+  "icon": "icons/steel.png",
+  "name": "steel-lang-2",
+  "version": "1.0.0",
+  "files": [
+    "src/",
+    "icons/"
+  ],
+  "description": "A simple, human-readable scripting language",
+  "main": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js examples/hello.steel"
+  },
+  "keywords": [
+    "language",
+    "interpreter",
+    "steel"
+  ],
+  "author": "theworker02",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/magnexis/Steel-lang.git"
+  }
+}

package/src/environment.js

@@ -0,0 +1,35 @@
+class Environment {
+
+  constructor() {
+
+    this.variables = {};
+
+  }
+
+
+
+  set(name, value) {
+
+    this.variables[name] = value;
+
+  }
+
+
+
+  get(name) {
+
+    if (!(name in this.variables)) {
+
+      throw new Error(`Variable "${name}" is not defined`);
+
+    }
+
+    return this.variables[name];
+
+  }
+
+}
+
+
+
+module.exports = Environment;

package/src/index.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+
+const { tokenize } = require('./lexer');
+
+const { parse } = require('./parser');
+
+const { interpret } = require('./interpreter');
+
+const Environment = require('./environment');
+
+
+
+const file = process.argv[2];
+
+
+
+if (!file) {
+
+  console.log("Usage: node src/index.js <file.steel>");
+
+  process.exit(1);
+
+}
+
+
+
+try {
+
+  const code = fs.readFileSync(file, 'utf-8');
+
+
+
+  const tokens = tokenize(code);
+
+  const ast = parse(tokens);
+
+
+
+  const env = new Environment();
+
+
+
+  interpret(ast, env);
+
+} catch (err) {
+
+  console.error("Error:", err.message);
+
+}

package/src/interpreter.js

@@ -0,0 +1,99 @@
+function interpret(ast, env) {
+
+  for (let node of ast) {
+
+
+
+    if (node.type === 'VariableDeclaration') {
+
+      const value = evaluate(node.value, env);
+
+      env.set(node.name, value);
+
+    }
+
+
+
+    if (node.type === 'SayStatement') {
+
+      const value = evaluate(node.value, env);
+
+      console.log(value);
+
+    }
+
+
+
+    if (node.type === 'IfStatement') {
+
+      const condition = evaluate(node.condition, env);
+
+
+
+      if (condition) {
+
+        interpret(node.body, env);
+
+      }
+
+    }
+
+
+
+  }
+
+}
+
+
+
+function evaluate(node, env) {
+
+  if (node.type === 'NUMBER') return node.value;
+
+  if (node.type === 'STRING') return node.value;
+
+
+
+  if (node.type === 'IDENTIFIER') {
+
+    return env.get(node.value);
+
+  }
+
+
+
+  if (node.type === 'BinaryExpression') {
+
+    const left = evaluate(node.left, env);
+
+    const right = evaluate(node.right, env);
+
+
+
+    switch (node.operator) {
+
+      case 'PLUS': return left + right;
+
+      case 'MINUS': return left - right;
+
+      case 'GT': return left > right;
+
+      case 'LT': return left < right;
+
+      case 'EQEQ': return left === right;
+
+    }
+
+  }
+
+
+
+  return null;
+
+}
+
+
+
+module.exports = { interpret };
+
+

package/src/lexer.js

@@ -0,0 +1,94 @@
+const KEYWORDS = {
+
+  set: 'SET',
+
+  to: 'TO',
+
+  say: 'SAY',
+
+  if: 'IF',
+
+  then: 'THEN',
+
+  end: 'END',
+
+};
+
+const OPERATORS = { 
+    '+': 'PLUS',
+    '-': 'MINUS',
+    '>': 'GT',
+    '<': 'LT',
+    '==': 'EQEQ',
+};
+
+
+
+function tokenize(input) {
+
+  const tokens = [];
+
+
+
+  const regex = /"[^"]*"|==|[+\-<>]|[^\s]+/g;
+
+  const words = input.match(regex) || [];
+
+
+
+  for (let word of words) {
+
+    if (OPERATORS[word]) {
+
+      tokens.push({ type: OPERATORS[word] });
+
+    }
+
+    else if (!isNaN(word)) {
+
+      tokens.push({ type: 'NUMBER', value: Number(word) });
+
+    }
+
+    else if (word.startsWith('"')) {
+
+      tokens.push({
+
+        type: 'STRING',
+
+        value: word.slice(1, -1)
+
+      });
+
+    }
+
+    else if (KEYWORDS[word]) {
+
+      tokens.push({ type: KEYWORDS[word] });
+
+    }
+
+    else {
+
+      tokens.push({
+
+        type: 'IDENTIFIER',
+
+        value: word
+
+      });
+
+    }
+
+  }
+
+
+
+  return tokens;
+
+}
+
+
+
+module.exports = { tokenize };
+

package/src/parser.js

@@ -0,0 +1,198 @@
+function parse(tokens) {
+
+  let i = 0;
+
+
+
+  function parseExpression() {
+
+    if (i >= tokens.length) {
+      throw new SyntaxError('Unexpected end of input');
+    }
+
+    const left = tokens[i++];
+
+
+
+    if (tokens[i] && ['PLUS', 'MINUS', 'GT', 'LT', 'EQEQ'].includes(tokens[i].type)) {
+
+      const operator = tokens[i++];
+
+      if (!tokens[i]) throw new SyntaxError('Expected right-hand operand');
+
+      const right = tokens[i++];
+
+
+
+      return {
+
+        type: 'BinaryExpression',
+
+        left,
+
+        operator: operator.type,
+
+        right
+
+      };
+
+    }
+
+
+
+    return left;
+
+  }
+
+
+
+  const ast = [];
+
+
+
+  while (i < tokens.length) {
+
+    const token = tokens[i];
+
+
+
+    // set x to ...
+
+    if (token.type === 'SET') {
+
+      if (!tokens[i + 1] || tokens[i + 1].type !== 'IDENTIFIER') {
+        throw new SyntaxError("'SET' expects a variable name");
+      }
+      if (!tokens[i + 2] || tokens[i + 2].type !== 'TO') {
+        throw new SyntaxError("'SET' expects 'TO' after variable name");
+      }
+
+      const name = tokens[i + 1].value;
+
+      i += 3; // skip SET name TO
+
+
+
+      const value = parseExpression();
+
+
+
+      ast.push({
+
+        type: 'VariableDeclaration',
+
+        name,
+
+        value
+
+      });
+
+    }
+
+
+
+    // say ...
+
+    else if (token.type === 'SAY') {
+
+      i++;
+
+      const value = parseExpression();
+
+
+
+      ast.push({
+
+        type: 'SayStatement',
+
+        value
+
+      });
+
+    }
+
+
+
+    // if condition then ... end
+
+    else if (token.type === 'IF') {
+
+      i++;
+
+
+
+      const condition = parseExpression();
+
+
+
+      if (!tokens[i] || tokens[i].type !== 'THEN') {
+        throw new SyntaxError("'IF' expects 'THEN' after condition");
+      }
+      i++; // skip THEN
+
+
+
+      const body = [];
+
+
+
+      while (tokens[i] && tokens[i].type !== 'END') {
+
+        if (tokens[i].type === 'SAY') {
+
+          i++;
+
+          body.push({
+
+            type: 'SayStatement',
+
+            value: parseExpression()
+
+          });
+
+        } else {
+
+          i++;
+
+        }
+
+      }
+
+      if (!tokens[i]) {
+        throw new SyntaxError("'IF' block missing 'END'");
+      }
+      i++; // skip END
+
+
+
+      ast.push({
+
+        type: 'IfStatement',
+
+        condition,
+
+        body
+
+      });
+
+    }
+
+
+
+    else {
+
+      i++;
+
+    }
+
+  }
+
+
+
+  return ast;
+
+}
+
+
+
+module.exports = { parse };