Repo Update

- Fixed links in README and on website

Author: jarroddavis68

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Join Facebook Group](https://img.shields.io/badge/Facebook-NitroPascal-blue?style=for-the-badge&logo=facebook)](https://www.facebook.com/groups/nitropascal)  [![Chat on Discord](https://img.shields.io/discord/754884471324672040?style=for-the-badge)](https://discord.gg/tinyBigGAMES) [![Follow on Bluesky](https://img.shields.io/badge/Bluesky-tinyBigGAMES-blue?style=for-the-badge&logo=bluesky)](https://bsky.app/profile/tinybiggames.com) 
+[![Join Facebook Group](https://img.shields.io/badge/Facebook-NitroPascal-blue?style=for-the-badge&logo=facebook)](https://www.facebook.com/groups/nitropascal)  [![Chat on Discord](https://img.shields.io/discord/754884471324672040?style=for-the-badge)](https://discord.gg/tPWjMwK) [![Follow on Bluesky](https://img.shields.io/badge/Bluesky-tinyBigGAMES-blue?style=for-the-badge&logo=bluesky)](https://bsky.app/profile/tinybiggames.com) 
 
 **Modern Pascal • C Performance**
 
@@ -32,11 +32,11 @@
 
 ## 🎯 Introduction
 
-NitroPascal is a next-generation Pascal implementation that bridges the elegance of Pascal with the raw performance of C. By combining modern language features with low-level optimization capabilities, NitroPascal aims to deliver the best of both worlds: readable, maintainable code that doesn't sacrifice speed.
+NitroPascal is a next-generation Pascal compiler that bridges the elegance of Object Pascal with the raw performance of C. By transpiling Object Pascal code to optimized C++, NitroPascal aims to deliver the best of both worlds: readable, maintainable code that doesn't sacrifice speed.
 
 ## 🔥 What Makes It Special?
 
-NitroPascal takes a revolutionary approach to achieving C-level performance: **transpilation**. Instead of interpreting or compiling directly to bytecode, NitroPascal transpiles modern NitroPascal code into highly optimized, idiomatic C++. This intermediate C++ representation is then compiled using **Zig as a drop-in C++ compiler**, with the entire build orchestrated through **build.zig**, unlocking:
+NitroPascal takes a revolutionary approach to achieving C-level performance: **transpilation**. Instead of interpreting or compiling directly to bytecode, NitroPascal transpiles Object Pascal code into highly optimized, idiomatic C++. This intermediate C++ representation is then compiled using **Zig as a drop-in C++ compiler**, with the entire build orchestrated through **build.zig**, unlocking:
 
 - 🎯 **Multi-Target Compilation**: Generate native binaries for Windows, Linux, macOS, and beyond
 - ⚡ **Aggressive Optimization**: Leverage decades of C++ compiler optimization research through Zig's LLVM backend
@@ -52,7 +52,7 @@ NitroPascal's compilation pipeline transforms your Pascal code through multiple
 
 ```
 ┌─────────────────┐
-│  NitroPascal    │  Write clean, modern Pascal code
+│  Object Pascal  │  Write clean, modern Pascal code
 │     Source      │
 └────────┬────────┘
          │
@@ -83,31 +83,37 @@ NitroPascal's compilation pipeline transforms your Pascal code through multiple
 
 ## 💻 Quick Example
 
-See how elegant Pascal code transforms into optimized C++:
+See how elegant Object Pascal code transforms into optimized C++:
 
 <table>
 <tr>
-<th>NitroPascal Source</th>
+<th>Object Pascal Source</th>
 <th>Generated C++ Code</th>
 </tr>
 <tr>
 <td>
 
 ```pascal
-$optimize "debug"
-
 program HelloWorld;
 
-extern <stdio.h> routine printf(format: ^char; ...): int;
+type
+  TPoint = record
+    X: Integer;
+    Y: Integer;
+  end;
 
-routine Greet(name: ^char);
+procedure PrintPoint(const P: TPoint);
 begin
-  printf("Hello, %s!\n", name);
+  WriteLn('Point(', P.X, ', ', P.Y, ')');
 end;
 
+var
+  Point: TPoint;
 begin
-  Greet("NitroPascal");
-  ExitCode := 0;
+  Point.X := 10;
+  Point.Y := 20;
+  PrintPoint(Point);
+  WriteLn('Hello from NitroPascal!');
 end.
 ```
 
@@ -116,14 +122,26 @@ end.
 
 ```cpp
 // Optimized C++ output
-#include <stdio.h>
+#include <iostream>
+
+struct TPoint {
+  int32_t X;
+  int32_t Y;
+};
 
-void Greet(const char* name) {
-  printf("Hello, %s!\n", name);
+void PrintPoint(const TPoint& P) {
+  std::wcout << L"Point(" << P.X 
+             << L", " << P.Y << L")" 
+             << std::endl;
 }
 
 int main() {
-  Greet("NitroPascal");
+  TPoint Point;
+  Point.X = 10;
+  Point.Y = 20;
+  PrintPoint(Point);
+  std::wcout << L"Hello from NitroPascal!" 
+             << std::endl;
   return 0;
 }
 ```
@@ -145,7 +163,7 @@ Pascal has always been celebrated for its clarity and strong typing, making it a
 
 ### Language & Syntax
 - 🎨 **Clean, expressive syntax** that doesn't compromise on power
-- 📝 **Modern Pascal syntax** with contemporary language features
+- 📝 **Object Pascal syntax** compatible with Delphi code
 - 🔒 **Memory safety** through strong typing without garbage collection overhead
 
 ### Performance & Optimization

website/index.html

@@ -753,37 +753,55 @@ <h2>💻 See It In Action</h2>
             </p>
             <div class="code-comparison">
                 <div class="code-block">
-                    <div class="code-header">NitroPascal Source</div>
+                    <div class="code-header">Object Pascal Source</div>
                     <div class="code-content">
-<span class="keyword">$optimize</span> <span class="string">"debug"</span>
-
 <span class="keyword">program</span> HelloWorld;
 
-<span class="keyword">extern</span> &lt;stdio.h&gt; <span class="keyword">routine</span> <span class="function">printf</span>(format: <span class="type">^char</span>; ...): <span class="type">int</span>;
+<span class="keyword">type</span>
+  <span class="type">TPoint</span> = <span class="keyword">record</span>
+    X: <span class="type">Integer</span>;
+    Y: <span class="type">Integer</span>;
+  <span class="keyword">end</span>;
 
-<span class="keyword">routine</span> <span class="function">Greet</span>(name: <span class="type">^char</span>);
+<span class="keyword">procedure</span> <span class="function">PrintPoint</span>(<span class="keyword">const</span> P: <span class="type">TPoint</span>);
 <span class="keyword">begin</span>
-  <span class="function">printf</span>(<span class="string">"Hello, %s!\n"</span>, name);
+  <span class="function">WriteLn</span>(<span class="string">'Point('</span>, P.X, <span class="string">', '</span>, P.Y, <span class="string">')'</span>);
 <span class="keyword">end</span>;
 
+<span class="keyword">var</span>
+  Point: <span class="type">TPoint</span>;
 <span class="keyword">begin</span>
-  <span class="function">Greet</span>(<span class="string">"NitroPascal"</span>);
-  ExitCode := <span class="number">0</span>;
+  Point.X := <span class="number">10</span>;
+  Point.Y := <span class="number">20</span>;
+  <span class="function">PrintPoint</span>(Point);
+  <span class="function">WriteLn</span>(<span class="string">'Hello from NitroPascal!'</span>);
 <span class="keyword">end</span>.
                     </div>
                 </div>
                 <div class="code-block">
                     <div class="code-header">Generated C++ Code</div>
                     <div class="code-content">
 <span class="comment">// Optimized C++ output</span>
-<span class="keyword">#include</span> <span class="string">&lt;stdio.h&gt;</span>
+<span class="keyword">#include</span> <span class="string">&lt;iostream&gt;</span>
+
+<span class="keyword">struct</span> <span class="type">TPoint</span> {
+  <span class="type">int32_t</span> X;
+  <span class="type">int32_t</span> Y;
+};
 
-<span class="keyword">void</span> <span class="function">Greet</span>(<span class="keyword">const</span> <span class="type">char</span>* name) {
-  <span class="function">printf</span>(<span class="string">"Hello, %s!\n"</span>, name);
+<span class="keyword">void</span> <span class="function">PrintPoint</span>(<span class="keyword">const</span> <span class="type">TPoint</span>&amp; P) {
+  <span class="type">std::wcout</span> &lt;&lt; <span class="string">L"Point("</span> &lt;&lt; P.X
+             &lt;&lt; <span class="string">L", "</span> &lt;&lt; P.Y &lt;&lt; <span class="string">L")"</span>
+             &lt;&lt; <span class="type">std::endl</span>;
 }
 
 <span class="keyword">int</span> <span class="function">main</span>() {
-  <span class="function">Greet</span>(<span class="string">"NitroPascal"</span>);
+  <span class="type">TPoint</span> Point;
+  Point.X = <span class="number">10</span>;
+  Point.Y = <span class="number">20</span>;
+  <span class="function">PrintPoint</span>(Point);
+  <span class="type">std::wcout</span> &lt;&lt; <span class="string">L"Hello from NitroPascal!"</span>
+             &lt;&lt; <span class="type">std::endl</span>;
   <span class="keyword">return</span> <span class="number">0</span>;
 }
                     </div>
@@ -828,7 +846,14 @@ <h2>🔧 Built With</h2>
                 Standing on the shoulders of giants
             </p>
             <div class="dependencies-grid">
-
+                <div class="dependency-card">
+                    <div class="dependency-icon">🌳</div>
+                    <h3>DelphiAST</h3>
+                    <p>Abstract Syntax Tree builder for Delphi - provides robust Pascal parsing capabilities that power NitroPascal's source code analysis.</p>
+                    <a href="https://github.com/RomanYankovsky/DelphiAST" class="dependency-link" target="_blank">
+                        View on GitHub →
+                    </a>
+                </div>
                 <div class="dependency-card">
                     <div class="dependency-icon">⚡</div>
                     <h3>LLVM</h3>