Create control backend for simulator

.github/workflows/deploy-docs.yml

@@ -0,0 +1,46 @@
+name: Deploy Docs to GitHub Pages
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  deploy-docs:
+    runs-on: ubuntu-latest
+    name: Build and Deploy Documentation
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup GitHub Pages
+        uses: actions/configure-pages@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.1'
+
+      - name: Generate Docs with Chirpy
+        uses: jsurrea/showcase-chirpy-easy-docs@v1.0.0
+        with:
+          docs-dir: docs
+
+      - name: Upload site artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: theme/_site
+
+      - name: Deploy to GitHub Pages
+        uses: actions/deploy-pages@v4

.github/workflows/rust-release.yml

@@ -0,0 +1,69 @@
+name: Rust Release
+
+permissions:
+  contents: write
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: taiki-e/create-gh-release-action@v1
+        with:
+          # (optional) Path to changelog.
+          # changelog: CHANGELOG.md
+          # (required) GitHub token for creating GitHub Releases.
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  upload-assets:
+    needs: create-release
+    defaults:
+      run:
+        working-directory: antares
+    strategy:
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu-latest
+          - target: x86_64-apple-darwin
+            os: macos-latest
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: taiki-e/upload-rust-binary-action@v1
+        with:
+          # (required) Comma-separated list of binary names (non-extension portion of filename) to build and upload.
+          # Note that glob pattern is not supported yet.
+          bin: ...
+          # (optional) Target triple, default is host triple.
+          # This is optional but it is recommended that this always be set to
+          # clarify which target you are building for if macOS is included in
+          # the matrix because GitHub Actions changed the default architecture
+          # of macos-latest since macos-14.
+          target: ${{ matrix.target }}
+          # (optional) On which platform to distribute the `.tar.gz` file.
+          # [default value: unix]
+          # [possible values: all, unix, windows, none]
+          tar: unix
+          # (optional) On which platform to distribute the `.zip` file.
+          # [default value: windows]
+          # [possible values: all, unix, windows, none]
+          zip: windows
+          # (optional) Archive name (non-extension portion of filename) to be uploaded.
+          # [default value: $bin-$target]
+          # [possible values: the following variables and any string]
+          #   variables:
+          #     - $bin    - Binary name (non-extension portion of filename).
+          #     - $target - Target triple.
+          #     - $tag    - Tag of this release.
+          # When multiple binary names are specified, default archive name or $bin variable cannot be used.
+          archive: $bin-$tag-$target
+          # (required) GitHub token for uploading assets to GitHub Releases.
+          token: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -1,105 +1,63 @@
-# ANTARES: A Software-Based Tool for Simulating Naval Radar Operations
+# ANTARES
 
-This repository contains the source code for ANTARES, a comprehensive naval radar simulation system designed to meet the operational needs of maritime security and training for the Colombian Navy. The system combines cutting-edge technology with modular and extensible architecture, providing a robust solution for naval simulation, real-time visualization, and tactical evaluation.
+**ANTARES** is an open-source, high-performance simulation platform for naval radar operations. It enables real-time, software-based simulation of maritime environments and radar tracking systems, with support for interactive visualization, TCP-based integration, and extensible simulation entities.
 
-## 🚢 **Project Overview**
+Developed with performance, modularity, and realism in mind, ANTARES supports both standalone and embedded use in larger C4I or Combat Management System (CMS) pipelines.
 
-### **Introduction**
+> 🧭 Showcase and live demos available at: [https://thesoftwaredesignlab.github.io/ANTARES](https://thesoftwaredesignlab.github.io/ANTARES)
 
-The project is aimed at developing an advanced naval radar simulator, capable of real-time detection, monitoring, and tracking of vessels in a simulated maritime environment. It supports realistic training, mission planning, and operational readiness, enhancing the Colombian Navy's capabilities and positioning it as a regional leader in naval technology.
+## Key Features
 
-### **Objective**
+- ⚡ **Real-Time Radar Simulation**  
+  Sub-10ms latency for real-time generation and transmission of radar data.
 
-- To design and implement a radar simulation system for generating and visualizing real-time data on vessel positions and movements in a simulated naval setting.
+- 🧱 **Modular & Extensible Architecture**  
+  Easily add new vessel behaviors, emitter types, or environmental effects.
 
-## 📂 **Repository Structure**
+- 🔒 **Secure & Standardized Communication**  
+  Transmit simulation data over TCP and WebSocket using standardized schemas.
 
-The repository is divided into three major components, each with its own dedicated subdirectory and README file for further details:
+- 🖥️ **Intuitive Web Interface**  
+  A reactive, interactive GUI for real-time control and visualization.
 
-### 1. **[Naval Radar Simulator](./naval-radar-simulator)**
+- 🚀 **High-Performance Core in Rust**  
+  Safety and speed for heavy computations and concurrent streaming.
 
-- Implements the radar simulation engine, responsible for generating radar data in real-time.
-- Developed in **Rust**, prioritizing:
-  - High performance.
-  - Security and low-level control.
-  - Configurability via TOML configuration files.
-- Real-time data is transmitted using TCP sockets.
-- Modular design supports extensibility for new features such as movement patterns, physical conditions, and custom tracking algorithms.
+## Repository Structure
 
-**Instructions to Run**:
+This monorepo contains all components of the ANTARES platform:
 
-```bash
-cd naval-radar-simulator
-cargo run -- <config-file>
 ```
-
-Replace `<config-file>` with the path to the desired TOML configuration file. Further setup instructions can be found in the subdirectory's [README](./naval-radar-simulator/README.md).
-
-### 2. **[Naval Radar Web UI](./naval-radar-web-ui)**
-
-- A **React-based user interface** for visualizing radar data.
-- Features include:
-  - Real-time radar display with panning and zoom functionality.
-  - Chat and control interface for interacting with the radar simulation.
-  - Communication with the radar engine using WebSockets.
-
-**Instructions to Run**:
-
-```bash
-cd naval-radar-web-ui
-npm install
-npm start
+ANTARES/
+├── antares/           # Core simulator (Rust)
+├── antares-python/    # Python client SDK
+├── antares-web/       # Web-based interface and dashboard (TypeScript + React)
+├── docs/              # Markdown source for documentation website
+├── LICENSE            # MIT License
+└── README.md          # You're here
 ```
 
-Open the interface in your browser at `http://localhost:5173`. Detailed information is available in the subdirectory's [README](./naval-radar-web-ui/README.md).
-
-### 3. **[Naval Radar Reverse Proxy](./naval-radar-reverse-proxy)**
-
-- Handles WebSocket connections between the web UI and radar simulation engine.
-- Ensures secure and optimized data transfer.
-- Configured to work seamlessly with both the simulation and web UI components.
-
-**Instructions to Run**:
-
-```bash
-cd naval-radar-reverse-proxy
-npm install
-npm start
-```
-
-Configuration details can be found in the subdirectory's [README](./naval-radar-reverse-proxy/README.md).
-
-## 🔧 **Key Features**
-
-- **Real-Time Radar Simulation**: Sub-10ms latency for precise real-time data.
-- **Extensibility**: Modular architecture allows integration of new entities and algorithms.
-- **Secure Communication**: Data is transmitted securely via standardized TCP and WebSocket protocols.
-- **Intuitive User Interface**: A highly interactive, user-friendly web interface for visualization and control.
-- **High Performance**: Built in Rust for efficient handling of radar computations and data streaming.
-
-## 📊 **Results and Impact**
-
-The simulator achieves its objectives by:
+Each subproject includes its own README with installation and usage instructions.
 
-1. Offering real-time, precise radar tracking.
-2. Providing extensibility for future needs, including new physical conditions and tracking enhancements.
-3. Meeting the operational training requirements of the Colombian Navy.
+- **[antares](./antares)** — The simulation engine written in Rust  
+- **[antares-python](./antares-python)** — A Python SDK and CLI for controlling and subscribing to simulation output  
+- **[antares-web](./antares-web)** — The user-facing control and visualization interface  
+- **[docs](./docs)** — Sources for the project website, built using [showcase-chirpy-easy-docs](https://github.com/jsurrea/showcase-chirpy-easy-docs)
 
-**System Performance**:
+## About the Project
 
-- Sub-10ms latency for seamless real-time updates.
-- Modular components ensure flexibility and scalability.
+> **ANTARES**: *A Software-Based Tool for Simulating Naval Radar Operations*  
+> Presented at the **International Conference on Military Technologies 2025**, Brno, Czechia.
 
-## 📜 **References**
+**Abstract**  
+Simulation is a cost-effective method for training personnel in virtual environments before operating real machines or interacting with real and complex scenarios. Moreover, simulation is also valuable for analyzing the behavior of both deployed systems and those under development. For instance, the design and operation of Combat Management and C4I systems, which are inherently complex, have utilized simulation for early validation as well as for training Navy officers and enlisted personnel.
 
-For further information on specific components, refer to the README files located in their respective directories:
+We present ANTARES, an open-source, software-based naval radar simulator. ANTARES is designed to seamlessly integrate with other systems via the TCP protocol while supporting standalone operation through a Graphical User Interface (GUI). Additionally, it adheres to the open-closed design principle, facilitating easy extensibility with new simulation entities, such as naval vessel movement strategies. The simulator was implemented using the Rust programming language due to its advantages in performance, type safety, concurrency, and memory safety. As an initial validation, we conducted a usability and usefulness study with 12 officers and enlisted personnel from the Colombian Navy. ANTARES is released under the MIT license.
 
-- [Naval Radar Simulator](./naval-radar-simulator/README.md)
-- [Naval Radar Web UI](./naval-radar-web-ui/README.md)
-- [Naval Radar Reverse Proxy](./naval-radar-reverse-proxy/README.md)
+## Credits
 
-## 📥 **Contributions**
+This project was developed by **Juan Sebastian Urrea-Lopez** as part of research initiatives at **Universidad de los Andes**, in collaboration with the **Armada de la República de Colombia**.
 
-This project was developed by **Juan Sebastian Urrea Lopez** as part of research initiatives at **Universidad de los Andes**, in collaboration with the **Armada de la República de Colombia**.
+## License
 
-For any contributions, suggestions, or issues, feel free to open a pull request or contact the authors directly.
+ANTARES is released under the [MIT License](./LICENSE).