From 4f0b68fb7e1d53c46b4b68d4cc997edb0e5b9d90 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 18:51:34 +0200 Subject: [PATCH 01/22] docs(camelot): rewrite to minimal plaintext style and direct copy --- src/layouts/CamelotDocsLayout.astro | 243 +--------- src/pages/docs/camelot/overview/index.md | 72 ++- src/pages/software/camelot.astro | 536 ++--------------------- src/styles/camelot-docs.css | 450 +++---------------- 4 files changed, 164 insertions(+), 1137 deletions(-) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index a69047d..fefc92c 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -20,70 +20,32 @@ const currentPath = Astro.url.pathname; {frontmatter.title} | Camelot Docs - -
- -
- Search... - Ctrl+K -
- GitHub +
+ Camelot Documentation + +
-
-
-

Camelot C Framework

+

Camelot

- Camelot is a C framework for when you just want predictable memory behavior and no surprises. - It uses memory arenas instead of random malloc calls, enforces standard C23 rules, and uses its own build engine (Merlin) instead of traditional makefiles or complex build scripts. + Camelot is a C framework structured for predictable memory execution under C23. + It utilizes memory arenas in place of arbitrary malloc calls, implements its own standard data structures, and is orchestrated by a dedicated build engine (Merlin). 

#include <camelot.h>
 
 int main(void) {
-    // Create an arena
+    /* Initialize memory pool */
     Arena *arena = ArenaInit(NULL, MEGABYTES(128));
 
-    // Allocate without worrying about freeing individual blocks
+    /* Allocate from arena; explicit deallocation per-block is unneeded */
     void *block = ArenaAlloc(arena, 1024);
 
     ArenaFree(&arena);
     return 0;
 }
-

Why use it?

+

Core Features

-

Get Started

+

Installation

-

You can clone and build it directly. No extra dependencies are needed.

+

The framework can be cloned and built directly without external package dependencies.

git clone https://github.com/yutila-org/camelot
 make
@@ -72,7 +72,7 @@ make diff --git a/src/styles/camelot-docs.css b/src/styles/camelot-docs.css index bc6c2df..9ae11cc 100644 --- a/src/styles/camelot-docs.css +++ b/src/styles/camelot-docs.css @@ -104,7 +104,145 @@ header { } .header-nav { - margin-left: 20px; + display: flex; + gap: 15px; + align-items: center; +} + +details { + margin-bottom: 1rem; +} + +summary { + cursor: pointer; + font-weight: bold; + margin-bottom: 0.5rem; + color: #fff; + list-style: none; /* Hide default triangle in some browsers */ + display: flex; + align-items: center; +} + +summary::-webkit-details-marker { + display: none; +} + +summary::before { + content: "▶"; + font-size: 0.8em; + margin-right: 8px; + transition: transform 0.2s; + color: #666; +} + +details[open] summary::before { + transform: rotate(90deg); +} + +details ul { + margin-left: 1.2rem; + margin-top: 0.5rem; +} + +/* Search Box / Trigger */ +.search-trigger { + background: #1e1e1e; + border: 1px solid #333; + color: #a0a0a0; + padding: 4px 10px; + cursor: pointer; + border-radius: 2px; + font-size: 0.9em; + display: flex; + align-items: center; + gap: 10px; +} + +.search-trigger:hover { + background: #252525; + color: #fff; +} + +kbd { + background: #333; + padding: 2px 4px; + border-radius: 2px; + font-size: 0.85em; + color: #e0e0e0; +} + +/* Search Modal */ +.search-overlay { + position: fixed; + inset: 0; + z-index: 1000; + background-color: rgba(0, 0, 0, 0.8); + display: flex; + align-items: flex-start; + justify-content: center; + padding-top: 15vh; +} + +.search-modal { + width: 100%; + max-width: 500px; + background-color: #1e1e1e; + border: 1px solid #444; + border-radius: 4px; + box-shadow: 0 4px 20px rgba(0,0,0,0.5); + display: flex; + flex-direction: column; +} + +.search-input-row { + display: flex; + align-items: center; + padding: 10px 15px; + border-bottom: 1px solid #333; +} + +.search-input-row input { + flex: 1; + background: none; + border: none; + color: #fff; + font-family: monospace; + font-size: 1rem; + outline: none; + margin: 0 10px; +} + +.search-results { + list-style: none; + max-height: 300px; + overflow-y: auto; + padding: 0; + margin: 0; +} + +.search-result-item a { + display: flex; + justify-content: space-between; + padding: 10px 15px; + color: #e0e0e0; + text-decoration: none; + border-bottom: 1px solid #222; +} + +.search-result-item.focused a, .search-result-item a:hover { + background: #2a2a2a; + color: #fff; +} + +.sr-section { + font-size: 0.8em; + color: #888; +} + +.search-empty { + padding: 15px; + color: #888; + text-align: center; } @media (max-width: 768px) { @@ -120,9 +258,6 @@ header { header { flex-direction: column; align-items: flex-start; - } - .header-nav { - margin-left: 0; - margin-top: 10px; + gap: 15px; } } From a1616b348178ebcb46e65c03728d1c392512647f Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:05:06 +0200 Subject: [PATCH 04/22] docs(camelot): remove code showcase, add debian-style table and borders --- src/pages/software/camelot.astro | 78 ++++++++++++++++++++++---------- 1 file changed, 55 insertions(+), 23 deletions(-) diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 93c921c..4ba944f 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -9,8 +9,42 @@ import '../../styles/camelot-docs.css'; Camelot + +
@@ -39,33 +73,31 @@ import '../../styles/camelot-docs.css'; It utilizes memory arenas in place of arbitrary malloc calls, implements its own standard data structures, and is orchestrated by a dedicated build engine (Merlin).

- 
#include <camelot.h>
-
-int main(void) {
-    /* Initialize memory pool */
-    Arena *arena = ArenaInit(NULL, MEGABYTES(128));
-
-    /* Allocate from arena; explicit deallocation per-block is unneeded */
-    void *block = ArenaAlloc(arena, 1024);
-
-    ArenaFree(&arena);
-    return 0;
-}
-

Core Features

-
    -
  • Merlin Build Engine: A dedicated build orchestrator written in D. It handles GCC flags, sanitizers, and compilation automatically.
    • -
  • Arena Allocators: Dynamic memory is strictly managed through arenas, ensuring O(1) allocations and eliminating traditional memory leaks.
    • -
  • Default Security Constraints: Projects are compiled with stack protectors, PIE, and ASAN/UBSAN to intercept common memory faults during execution.
    • -
+ + + + + + + + + + + + + + + +
Build EngineA dedicated build orchestrator written in D named Merlin. It handles compiler flags, sanitizers, and compilation automatically, removing the need for external build systems.
Memory AllocationDynamic memory is strictly managed through arenas. This guarantees O(1) allocation times and structurally eliminates traditional memory leaks.
SecurityProjects are compiled with stack protectors, PIE, and ASAN/UBSAN to intercept common memory faults during execution.
-

Installation

- -

The framework can be cloned and built directly without external package dependencies.

- - 
git clone https://github.com/yutila-org/camelot
+            

+                Installation Instructions
+                
The framework can be cloned and built directly without external package dependencies.

+                
git clone https://github.com/yutila-org/camelot
 make

+
From d933cbf6d9688eb707b4a6e296f98beb94341e26 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:06:40 +0200 Subject: [PATCH 05/22] docs(camelot): add table of contents back to sidebar --- src/layouts/CamelotDocsLayout.astro | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 1dc8b6a..1c64d86 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -63,6 +63,19 @@ const currentPath = Astro.url.pathname;
  • I/O Utilities
    • + + {headings && headings.length > 0 && ( +
    +

    On this page

    + +
    + )} From b70e5fa6bd23c77597edc04b31baf130b4b92c12 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:08:50 +0200 Subject: [PATCH 06/22] docs(camelot): add hand-coded architectural svgs and icons --- src/pages/software/camelot.astro | 97 +++++++++++++++++++++++++++++--- 1 file changed, 89 insertions(+), 8 deletions(-) diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 4ba944f..dee3a3a 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -18,6 +18,33 @@ import '../../styles/camelot-docs.css'; top: 0; left: 0; } + .hero-section { + display: flex; + align-items: center; + gap: 40px; + margin-top: 2em; + margin-bottom: 3em; + } + .hero-text { + flex: 1; + } + .hero-graphic { + flex-shrink: 0; + padding: 20px; + background: #1a1a1a; + border: 1px solid #333; + border-radius: 4px; + display: flex; + flex-direction: column; + align-items: center; + } + .hero-graphic span { + font-size: 0.8em; + color: #888; + margin-top: 10px; + text-transform: uppercase; + letter-spacing: 1px; + } .content-table { width: 100%; border-collapse: collapse; @@ -25,9 +52,10 @@ import '../../styles/camelot-docs.css'; border: 1px solid #333; } .content-table th, .content-table td { - padding: 12px 15px; + padding: 15px; border: 1px solid #333; text-align: left; + vertical-align: top; } .content-table th { background-color: #1a1a1a; @@ -35,12 +63,22 @@ import '../../styles/camelot-docs.css'; font-weight: bold; width: 25%; } + .th-inner { + display: flex; + align-items: center; + gap: 10px; + } .info-box { background-color: #1a1a1a; border-left: 4px solid #d70a53; padding: 15px; margin: 2em 0; } + @media (max-width: 768px) { + .hero-section { + flex-direction: column; + } + } @@ -68,25 +106,68 @@ import '../../styles/camelot-docs.css';

    Camelot

    -

    - Camelot is a C framework structured for predictable memory execution under C23. - It utilizes memory arenas in place of arbitrary malloc calls, implements its own standard data structures, and is orchestrated by a dedicated build engine (Merlin). -

    +
    +
    +

    + Camelot is a C framework structured for predictable memory execution under C23. + It utilizes memory arenas in place of arbitrary malloc calls, implements its own standard data structures, and is orchestrated by a dedicated build engine (Merlin). +

    +

    + The architecture emphasizes absolute control over the runtime environment, eschewing magic and unpredictable latency spikes. +

    +
    + + +
    + + + + + + + + + + + + + + + + + Arena Memory Map +
    +

    Core Features

    - + - + - + From 40145bba0f65ce455fe538bd746dc2327ffff595 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:10:38 +0200 Subject: [PATCH 07/22] docs(camelot): remove useless arena memory map svg --- src/pages/software/camelot.astro | 39 +------------------------------- 1 file changed, 1 insertion(+), 38 deletions(-) diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index dee3a3a..1c6f5be 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -28,23 +28,7 @@ import '../../styles/camelot-docs.css'; .hero-text { flex: 1; } - .hero-graphic { - flex-shrink: 0; - padding: 20px; - background: #1a1a1a; - border: 1px solid #333; - border-radius: 4px; - display: flex; - flex-direction: column; - align-items: center; - } - .hero-graphic span { - font-size: 0.8em; - color: #888; - margin-top: 10px; - text-transform: uppercase; - letter-spacing: 1px; - } + .content-table { width: 100%; border-collapse: collapse; @@ -116,27 +100,6 @@ import '../../styles/camelot-docs.css'; The architecture emphasizes absolute control over the runtime environment, eschewing magic and unpredictable latency spikes.

    - - -
    - - - - - - - - - - - - - - - - - Arena Memory Map -

    Core Features

    From c1cca7b64a27518eecce08c8ac8908f6fe4123da Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:13:55 +0200 Subject: [PATCH 08/22] docs(camelot): fix search bar csp, increase font size, add openssf badge --- public/search.js | 136 ++++++++++++++++++++++++++++ src/layouts/CamelotDocsLayout.astro | 136 +--------------------------- src/pages/software/camelot.astro | 4 +- src/styles/camelot-docs.css | 1 + 4 files changed, 140 insertions(+), 137 deletions(-) create mode 100644 public/search.js diff --git a/public/search.js b/public/search.js new file mode 100644 index 0000000..f9b3528 --- /dev/null +++ b/public/search.js @@ -0,0 +1,136 @@ +const pages = [ + { title: 'Introduction', section: 'Overview', href: '/docs/camelot/overview' }, + { title: 'Architecture', section: 'Overview', href: '/docs/camelot/overview/architecture' }, + { title: 'Memory Allocator', section: 'Overview', href: '/docs/camelot/overview/memory' }, + { title: 'Merlin Build Engine', section: 'Core Systems', href: '/docs/camelot/core/merlin' }, + { title: 'I/O Utilities', section: 'Core Systems', href: '/docs/camelot/core/io' } +]; + +document.addEventListener('DOMContentLoaded', () => { + const overlay = document.getElementById('search-overlay'); + const searchInput = document.getElementById('search-input'); + const resultsList = document.getElementById('search-results'); + const emptyMsg = document.getElementById('search-empty'); + const trigger = document.getElementById('search-trigger'); + + let activeIdx = -1; + let isOpen = false; + + if (overlay && searchInput && resultsList && emptyMsg && trigger) { + const openSearch = () => { + isOpen = true; + overlay.style.display = 'flex'; + searchInput.value = ''; + activeIdx = -1; + emptyMsg.style.display = 'none'; + renderResults(pages); + setTimeout(() => { searchInput.focus(); }, 50); + }; + + const closeSearch = () => { + isOpen = false; + overlay.style.display = 'none'; + searchInput.blur(); + }; + + const renderResults = (items) => { + resultsList.innerHTML = ''; + if (items.length === 0) { + emptyMsg.style.display = 'block'; + return; + } + emptyMsg.style.display = 'none'; + items.forEach((item, idx) => { + const li = document.createElement('li'); + li.className = 'search-result-item'; + + const a = document.createElement('a'); + a.href = item.href; + + const titleSpan = document.createElement('span'); + titleSpan.className = 'sr-title'; + titleSpan.textContent = item.title; + + const sectionSpan = document.createElement('span'); + sectionSpan.className = 'sr-section'; + sectionSpan.textContent = item.section; + + a.appendChild(titleSpan); + a.appendChild(sectionSpan); + li.appendChild(a); + + li.addEventListener('mouseenter', () => { + activeIdx = idx; + highlightResult(); + }); + + resultsList.appendChild(li); + }); + }; + + const highlightResult = () => { + const items = resultsList.querySelectorAll('.search-result-item'); + items.forEach((item, idx) => { + if (idx === activeIdx) { + item.classList.add('focused'); + } else { + item.classList.remove('focused'); + } + }); + }; + + trigger.addEventListener('click', (e) => { + e.preventDefault(); + e.stopPropagation(); + openSearch(); + }); + + document.addEventListener('keydown', (e) => { + if ((e.ctrlKey || e.metaKey) && e.key === 'k') { + e.preventDefault(); + openSearch(); + return; + } + if (!isOpen) return; + if (e.key === 'Escape') { + closeSearch(); + return; + } + const items = resultsList.querySelectorAll('.search-result-item'); + if (e.key === 'ArrowDown') { + e.preventDefault(); + activeIdx = Math.min(activeIdx + 1, items.length - 1); + highlightResult(); + const activeEl = items[activeIdx]; + if (activeEl) activeEl.scrollIntoView({ block: 'nearest' }); + } + if (e.key === 'ArrowUp') { + e.preventDefault(); + activeIdx = Math.max(activeIdx - 1, 0); + highlightResult(); + const activeEl = items[activeIdx]; + if (activeEl) activeEl.scrollIntoView({ block: 'nearest' }); + } + if (e.key === 'Enter' && activeIdx >= 0 && items[activeIdx]) { + const link = items[activeIdx].querySelector('a'); + if (link) window.location.href = link.href; + } + }); + + overlay.addEventListener('click', (e) => { + if (e.target === overlay) closeSearch(); + }); + + searchInput.addEventListener('input', () => { + const q = searchInput.value.toLowerCase().trim(); + const filtered = pages.filter(page => + !q || + page.title.toLowerCase().includes(q) || + page.section.toLowerCase().includes(q) + ); + activeIdx = filtered.length > 0 ? 0 : -1; + renderResults(filtered); + highlightResult(); + }); + } +}); diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 1c64d86..a4cd7da 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -99,140 +99,6 @@ const currentPath = Astro.url.pathname; - + diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 1c6f5be..ead91d3 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -148,8 +148,8 @@ make diff --git a/src/styles/camelot-docs.css b/src/styles/camelot-docs.css index 9ae11cc..acb777c 100644 --- a/src/styles/camelot-docs.css +++ b/src/styles/camelot-docs.css @@ -2,6 +2,7 @@ body { font-family: monospace; + font-size: 18px; line-height: 1.6; max-width: 1400px; margin: 40px auto; From dd8d03be322b473cd971402e932618a7b492fb46 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:15:24 +0200 Subject: [PATCH 09/22] docs(camelot): decrease font size and add openssf badge to sidebar --- src/layouts/CamelotDocsLayout.astro | 6 ++++++ src/styles/camelot-docs.css | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index a4cd7da..f63283e 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -76,6 +76,12 @@ const currentPath = Astro.url.pathname; )} + +
    + + OpenSSF Best Practices + +
    diff --git a/src/styles/camelot-docs.css b/src/styles/camelot-docs.css index acb777c..4606707 100644 --- a/src/styles/camelot-docs.css +++ b/src/styles/camelot-docs.css @@ -2,7 +2,7 @@ body { font-family: monospace; - font-size: 18px; + font-size: 15px; line-height: 1.6; max-width: 1400px; margin: 40px auto; From d41bb24e1f15d2370256f4809b929e3a534bbc44 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:16:16 +0200 Subject: [PATCH 10/22] docs(camelot): add is:inline directive to script to fix astro build error --- src/layouts/CamelotDocsLayout.astro | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index f63283e..7e6dfdb 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -105,6 +105,6 @@ const currentPath = Astro.url.pathname; - + From d57f393ade4cc94d6195a0a1857e075c20a4b80f Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:18:05 +0200 Subject: [PATCH 11/22] docs(camelot): fix openssf badge url and update logo link --- src/layouts/CamelotDocsLayout.astro | 4 ++-- src/pages/software/camelot.astro | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 7e6dfdb..59fe761 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -24,7 +24,7 @@ const currentPath = Astro.url.pathname;
    - + @@ -79,7 +79,7 @@ const currentPath = Astro.url.pathname; diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index ead91d3..aa8d355 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -69,7 +69,7 @@ import '../../styles/camelot-docs.css';
    - + @@ -149,7 +149,7 @@ make

    Distributed under the MPL 2.0.

    - OpenSSF Best Practices + OpenSSF Best Practices

    From c73b2b396c4e5995ef48eb4751ba159d98b0b92c Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:24:07 +0200 Subject: [PATCH 12/22] docs: rewrite text across yutila pages for utilitarian tone and native openssf badge --- public/openssf-badge.svg | 1 + src/layouts/CamelotDocsLayout.astro | 2 +- src/pages/about.astro | 15 +++++++-------- src/pages/index.astro | 4 ++-- src/pages/software/camelot.astro | 2 +- src/pages/software/index.astro | 6 +++--- src/pages/software/stario.astro | 17 ++++++----------- 7 files changed, 21 insertions(+), 26 deletions(-) create mode 100644 public/openssf-badge.svg diff --git a/public/openssf-badge.svg b/public/openssf-badge.svg new file mode 100644 index 0000000..18e93a6 --- /dev/null +++ b/public/openssf-badge.svg @@ -0,0 +1 @@ +openssf best practices: passingopenssf best practicespassing \ No newline at end of file diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 59fe761..7164973 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -79,7 +79,7 @@ const currentPath = Astro.url.pathname; diff --git a/src/pages/about.astro b/src/pages/about.astro index 3c2f9b8..b87a68c 100644 --- a/src/pages/about.astro +++ b/src/pages/about.astro @@ -16,9 +16,8 @@ import PageHeader from '../components/PageHeader.astro';
    -

    Our Mission

    -

    We are a multidisciplinary studio that has moved past our hobbyist roots and are now organized into three core domains: Governance, Security, and Engineering.

    -

    Our goal is to build an equitable organization driven by contributor passion, delivering exceptional work. We challenge conventional paradigms to advance technology, digital art, and interactive media. Yutila is a structured collective where specialized talent converges to create unparalleled systems.

    +

    Project Mandate

    +

    The Yutila Project is structured into three core domains: Governance, Security and Engineering. The objective is the development of robust and high-performance systems driven by technical merit rather than conventional paradigms.

    @@ -28,15 +27,15 @@ import PageHeader from '../components/PageHeader.astro'; Pre-revenue
    -

    Operating under a minimal budget mandate, we rely on high technical competency, dedication, and open-source collaboration. Our ecosystem is built by specialists who are driven by the ambition to craft exceptional systems.

    +

    Operations are sustained through strict technical competency and open-source validation. The ecosystem relies on specialized contributions.

    -

    How we work

    -

    Yutila operates as a multidisciplinary technical incubator where growth is dictated by verifiable technical merit. We advance projects through a proposal-driven lifecycle, framing internal initiatives as rigorous hypotheses to be tested against engineering reality.

    +

    Development Methodology

    +

    Projects advance through a proposal-driven lifecycle requiring verifiable technical merit and rigorous testing against engineering reality.

    @@ -44,7 +43,7 @@ import PageHeader from '../components/PageHeader.astro'; For Collaborators -

    We empower contributors by providing a structured path from ideation to implementation.

    +

    Contributions require structured framing and formal design documentation. Proposals undergo a critical evaluation process prioritizing precision and feasibility.

    • @@ -72,7 +71,7 @@ import PageHeader from '../components/PageHeader.astro'; For Investors -

      Our internal development model is engineered to ensure stability, security, and enterprise-grade reliability.

      +

      Development aligns with strict security adherence, standardized SecOps compliance and deterministic transaction stability.

      • diff --git a/src/pages/index.astro b/src/pages/index.astro index 1f2462c..9a5620d 100644 --- a/src/pages/index.astro +++ b/src/pages/index.astro @@ -42,12 +42,12 @@ const icons = [ /> ))}
        -

        Building the future of
        +

        Yutila
        Technology

        -

        Yutila is an organization focused on software, games and in the future hardware.

        +

        A technical collective focused on the engineering of software, interactive media and hardware infrastructure.

    diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index aa8d355..30589f7 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -149,7 +149,7 @@ make

    Distributed under the MPL 2.0.

    - OpenSSF Best Practices + OpenSSF Best Practices

    diff --git a/src/pages/software/index.astro b/src/pages/software/index.astro index be45d11..549b2cd 100644 --- a/src/pages/software/index.astro +++ b/src/pages/software/index.astro @@ -10,7 +10,7 @@ import Layout from '../../layouts/Layout.astro'; Back to Home

    Software

    -

    Tools, applications, and infrastructure built and maintained by Yutila.

    +

    Tools, applications and infrastructure maintained by the Yutila Project.

    @@ -28,7 +28,7 @@ import Layout from '../../layouts/Layout.astro';

    Stario

    -

    Android's launcher for you. Zero bloat. Zero noise. Pure function.

    +

    Android application launcher. Minimal footprint. Localized data. Zero background telemetry.

    @@ -41,7 +41,7 @@ import Layout from '../../layouts/Layout.astro';

    Camelot

    -

    C23 executed with precision. Zero latency. Strict memory safety.

    +

    C23 framework. Predictable memory execution. Custom build orchestration.

    diff --git a/src/pages/software/stario.astro b/src/pages/software/stario.astro index 854e896..a2b474e 100644 --- a/src/pages/software/stario.astro +++ b/src/pages/software/stario.astro @@ -550,14 +550,10 @@ const images = Object.keys(imageFiles).map(file => file.replace('/public', ''));
    -

    Android's launcher for you.

    -

    Zero bloat. Zero noise. Pure function.

    +

    Android Application Launcher.

    +

    Minimal footprint. Localized data. Zero telemetry.

    - Stario is an Android launcher built for extreme - minimalism and utility. It provides a clean, ad-free - interface featuring local widgets, Material You - integration, and built-in search, completely free of - background telemetry. + Stario is engineered for structural minimalism. It provides a native interface featuring local widgets and Material You integration while operating under a strict zero-telemetry mandate.

    @@ -606,8 +602,8 @@ const images = Object.keys(imageFiles).map(file => file.replace('/public', ''));

    Dynamic Integration

    - Integrates natively with Android's Material You dynamic - color APIs for seamless system-level adaptation. + Integrates natively with Android Material You dynamic + color APIs for seamless system level adaptation.

    @@ -656,8 +652,7 @@ const images = Object.keys(imageFiles).map(file => file.replace('/public', ''));

    Telemetry-Free

    - No advertisements. No algorithmically driven feeds. - Absolute zero background data collection. + Absolute zero background data collection. No advertisements. No algorithmically driven feeds.

    From 0e29debb1ea92b4f40580cc76f6744287ab02b63 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:25:26 +0200 Subject: [PATCH 13/22] docs: change homepage hero text to rainbow yutila --- src/pages/index.astro | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pages/index.astro b/src/pages/index.astro index 9a5620d..f072ec7 100644 --- a/src/pages/index.astro +++ b/src/pages/index.astro @@ -42,9 +42,9 @@ const icons = [ /> ))} -

    Yutila
    +

    - Technology + Yutila

    A technical collective focused on the engineering of software, interactive media and hardware infrastructure.

    From fc435d4911cc94a28687562658e12f8428e7c6ac Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:26:42 +0200 Subject: [PATCH 14/22] docs: remove comma from homepage subheader --- src/pages/index.astro | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pages/index.astro b/src/pages/index.astro index f072ec7..6b66fc8 100644 --- a/src/pages/index.astro +++ b/src/pages/index.astro @@ -47,7 +47,7 @@ const icons = [ Yutila -

    A technical collective focused on the engineering of software, interactive media and hardware infrastructure.

    +

    A technical collective focused on the engineering of software and interactive media and hardware infrastructure.

    From 005632b6b4db2643844a129a9e6a1f56f2504d82 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:29:42 +0200 Subject: [PATCH 15/22] docs: remove shields.io badges and redesign camelot page like debian --- src/layouts/CamelotDocsLayout.astro | 4 ++-- src/pages/software/camelot.astro | 32 +++++++++++++++++++++++++++-- 2 files changed, 32 insertions(+), 4 deletions(-) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 7164973..795e875 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -78,8 +78,8 @@ const currentPath = Astro.url.pathname; )} diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 30589f7..849bd66 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -102,6 +102,34 @@ import '../../styles/camelot-docs.css'; +
    +
    +

    + + Getting Camelot +

    +

    + Clone the repository directly. The framework requires no external package dependencies. +

    + 
    git clone https://github.com/yutila-org/camelot
+cd camelot
+make
    +
    + +
    +

    + + Documentation +

    +

    + Comprehensive manuals covering the memory allocator, I/O utilities, and the Merlin build engine. +

    + + Read the Manual + +
    +
    +

    Core Features

    Build Engine +
    + + Build Engine +
    +     		A dedicated build orchestrator written in D named Merlin. It handles compiler flags, sanitizers, and compilation automatically, removing the need for external build systems.
    Memory Allocation +
    + + Memory Allocation +
    +     		Dynamic memory is strictly managed through arenas. This guarantees O(1) allocation times and structurally eliminates traditional memory leaks.
    Security +
    + + Security +
    +     		Projects are compiled with stack protectors, PIE, and ASAN/UBSAN to intercept common memory faults during execution.
    @@ -148,8 +176,8 @@ make From 3049cb6598a8a4ab47f50ccbf619be736bba6a79 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:32:44 +0200 Subject: [PATCH 16/22] docs: add native openssf passing logo --- public/openssf-passing.svg | 1 + src/layouts/CamelotDocsLayout.astro | 4 ++-- src/pages/software/camelot.astro | 4 +++- 3 files changed, 6 insertions(+), 3 deletions(-) create mode 100644 public/openssf-passing.svg diff --git a/public/openssf-passing.svg b/public/openssf-passing.svg new file mode 100644 index 0000000..bc7433e --- /dev/null +++ b/public/openssf-passing.svg @@ -0,0 +1 @@ +passingpassing \ No newline at end of file diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 795e875..e7b7a8c 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -78,8 +78,8 @@ const currentPath = Astro.url.pathname; )} diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 849bd66..d4778b9 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -177,7 +177,9 @@ make

    Distributed under the MPL 2.0.

    - OpenSSF Certified + + OpenSSF Passing +

    From 0380ec7fb0d66813df34b7ab2941a8bd8d383fd0 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:34:20 +0200 Subject: [PATCH 17/22] chore: allow unsafe-inline scripts in CSP --- src/middleware.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/middleware.ts b/src/middleware.ts index 0e7d870..53da2f7 100644 --- a/src/middleware.ts +++ b/src/middleware.ts @@ -6,7 +6,7 @@ const securityHeaders: Record = { 'Referrer-Policy': 'strict-origin-when-cross-origin', 'Strict-Transport-Security': 'max-age=63072000; includeSubDomains; preload', 'Content-Security-Policy': - "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'self'; object-src 'none'; frame-ancestors 'none'; upgrade-insecure-requests", + "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; base-uri 'self'; object-src 'none'; frame-ancestors 'none'; upgrade-insecure-requests", }; export const onRequest = defineMiddleware(async (_context, next) => { From 03ce68dc57a0d7af746f4c6e60c5ec2608c8c3be Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:36:21 +0200 Subject: [PATCH 18/22] docs: replace tiny passing svg with official openssf png logo --- public/openssf-logo.png | Bin 0 -> 839 bytes src/layouts/CamelotDocsLayout.astro | 2 +- src/pages/software/camelot.astro | 2 +- 3 files changed, 2 insertions(+), 2 deletions(-) create mode 100644 public/openssf-logo.png diff --git a/public/openssf-logo.png b/public/openssf-logo.png new file mode 100644 index 0000000000000000000000000000000000000000..e2bd9c28e8d9bf79dce64aa9a55e33bd060797e2 GIT binary patch literal 839 zcmV-N1GxN&P)7BBDd0gOe#@M1voT2r+dbYAB)`33Z`65or_DMloE73yA`8qeg-Y z9UM^<#Sa9tv>`IWj~P&7)WwWrS~_F>T%0@bdgq+`-dFm=-8_fq{LVS|`KqXt)JR}H zFc)|i7zYdk`hXsw1NaHJ3_ObNpw{|ks=L(=%c)DOz%@ga6q_z+qrg*`HZL{{kx-a>m)f5nw`rV?XdKa1(e&2$Ck?ePBew z=QrR^_07ft7l2s_hX=r3pcVKB7?Xkefo?!x39y9_tpoZ6SPtB;{!e=g-u-)ZqB>ta zq~24XR|P_sdR$$qj#adqwX&m5N+x-b))*8k}S+U(XCX50K+3^=mr`i_732$>?YOv1ZXL|6)+@WuMjFjUc(4=?s?Asl2E#8!k$Fz zjlkWAeKIfu_%dhT1N>eF_GiRC7r4dX(^d%e@j5UE*hZ*_2Z4oUV6hW@On92Jk+mtn zMPM!Pn9!0=11BTx7PvFFh;CM!7vOo zFgZiKbq*wh)9j|_)E{nl1RE?BwsEZ8Gx;Z<*EyMG7 zs%O>D4gIUd@FHdxSP+9XsI4_le#+1drmIs7t)waYRvP+Zf6k|80GOYy#sh6x4i)JI zAwPQwLrx>bz8i9;JTwKY?1!`dqC!f4TbO8$$jtL~yBD zf8ZNx=xs;TM>POF>PdCIVSagSuh{rqqzQz{w;7lSyiFKbyMRuhop`qZ;1xx{@Q4YM R!`1)*002ovPDHLkV1nhAe%$~7 literal 0 HcmV?d00001 diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index e7b7a8c..f943ca9 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -79,7 +79,7 @@ const currentPath = Astro.url.pathname; diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index d4778b9..73027c9 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -178,7 +178,7 @@ make

    Distributed under the MPL 2.0.

    - OpenSSF Passing + OpenSSF Best Practices

    From 03bbf0e0e1b63e4451c4d7985af5c3ba6e1b428e Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:38:53 +0200 Subject: [PATCH 19/22] docs: replace logo with custom utilitarian badge --- public/openssf-badge.svg | 7 ++++++- src/layouts/CamelotDocsLayout.astro | 2 +- src/pages/software/camelot.astro | 2 +- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/public/openssf-badge.svg b/public/openssf-badge.svg index 18e93a6..24f014b 100644 --- a/public/openssf-badge.svg +++ b/public/openssf-badge.svg @@ -1 +1,6 @@ -openssf best practices: passingopenssf best practicespassing \ No newline at end of file + + + + OpenSSF + PASSING + \ No newline at end of file diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index f943ca9..8342c13 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -79,7 +79,7 @@ const currentPath = Astro.url.pathname; diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 73027c9..97c9d6d 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -178,7 +178,7 @@ make

    Distributed under the MPL 2.0.

    - OpenSSF Best Practices + OpenSSF Best Practices: Passing

    From 53f97740e362303b2966c7daf9912002cac157e9 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Fri, 22 May 2026 19:41:14 +0200 Subject: [PATCH 20/22] docs: move openssf badge to top and add explanation --- src/layouts/CamelotDocsLayout.astro | 3 ++- src/pages/software/camelot.astro | 9 ++++++--- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 8342c13..1cb5aed 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -78,9 +78,10 @@ const currentPath = Astro.url.pathname; )}
    - + OpenSSF Best Practices: Passing + Certifies adherence to secure software development practices.
    diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 97c9d6d..8888bf1 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -89,6 +89,12 @@ import '../../styles/camelot-docs.css';

    Camelot

    +
    + + OpenSSF Best Practices: Passing + + OpenSSF certification verifies adherence to secure software development and supply chain practices. +
    @@ -177,9 +183,6 @@ make

    Distributed under the MPL 2.0.

    - - OpenSSF Best Practices: Passing -

    From 08c46a6cf3b6fafe8333f70fcfa3d8eaa258ea38 Mon Sep 17 00:00:00 2001 From: AKRiLLiCK Date: Fri, 22 May 2026 21:23:04 +0200 Subject: [PATCH 21/22] updated docs and added our compliance --- public/icons/iec-logo.svg | 5 + public/icons/iso-logo.svg | 5 + public/icons/openchain-conformance.svg | 125 +++++++++++++++++++++++++ src/layouts/CamelotDocsLayout.astro | 3 +- src/layouts/StarioDocsLayout.astro | 6 +- src/pages/about.astro | 34 +++---- src/pages/governance.astro | 2 + src/pages/index.astro | 104 +++++++++++++++++++- 8 files changed, 265 insertions(+), 19 deletions(-) create mode 100644 public/icons/iec-logo.svg create mode 100644 public/icons/iso-logo.svg create mode 100644 public/icons/openchain-conformance.svg diff --git a/public/icons/iec-logo.svg b/public/icons/iec-logo.svg new file mode 100644 index 0000000..1937709 --- /dev/null +++ b/public/icons/iec-logo.svg @@ -0,0 +1,5 @@ + + + + IEC + \ No newline at end of file diff --git a/public/icons/iso-logo.svg b/public/icons/iso-logo.svg new file mode 100644 index 0000000..a6e2399 --- /dev/null +++ b/public/icons/iso-logo.svg @@ -0,0 +1,5 @@ + + + + ISO + \ No newline at end of file diff --git a/public/icons/openchain-conformance.svg b/public/icons/openchain-conformance.svg new file mode 100644 index 0000000..cce8a68 --- /dev/null +++ b/public/icons/openchain-conformance.svg @@ -0,0 +1,125 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Open Source License Compliance Program + \ No newline at end of file diff --git a/src/layouts/CamelotDocsLayout.astro b/src/layouts/CamelotDocsLayout.astro index 1cb5aed..989dff0 100644 --- a/src/layouts/CamelotDocsLayout.astro +++ b/src/layouts/CamelotDocsLayout.astro @@ -38,7 +38,8 @@ const currentPath = Astro.url.pathname;
    Search... Ctrl+K
    - Home | + Camelot | + Software | GitHub diff --git a/src/layouts/StarioDocsLayout.astro b/src/layouts/StarioDocsLayout.astro index 1babad8..6e1c10f 100644 --- a/src/layouts/StarioDocsLayout.astro +++ b/src/layouts/StarioDocsLayout.astro @@ -35,7 +35,11 @@ const currentPath = Astro.url.pathname; Search... Ctrl+K
    - GitHub +
    + Stario + Software + GitHub +
    diff --git a/src/pages/about.astro b/src/pages/about.astro index b87a68c..b9b1804 100644 --- a/src/pages/about.astro +++ b/src/pages/about.astro @@ -17,7 +17,7 @@ import PageHeader from '../components/PageHeader.astro';

    Project Mandate

    -

    The Yutila Project is structured into three core domains: Governance, Security and Engineering. The objective is the development of robust and high-performance systems driven by technical merit rather than conventional paradigms.

    +

    Yutila is an independent, community-driven collective dedicated to crafting robust and high‑performance software, interactive media, and open hardware. We are built on a foundation of collaboration, technical transparency, and a deep respect for developer freedom and digital rights, rejecting rigid corporate dogmas to focus on what truly matters: elegant, secure, and user-centric engineering.

    @@ -25,43 +25,43 @@ import PageHeader from '../components/PageHeader.astro';

    Operational Status

    - Pre-revenue + Independent & Pre-revenue
    -

    Operations are sustained through strict technical competency and open-source validation. The ecosystem relies on specialized contributions.

    +

    We are entirely self-funded, independent, and community-supported. Rather than chasing corporate profits or commercial venture capital, Yutila is sustained by shared passion, open-source validation, and collaborative effort. We rely on the diverse minds, perspectives, and skills of developers who believe in building a freer, more transparent web.

    -

    Development Methodology

    -

    Projects advance through a proposal-driven lifecycle requiring verifiable technical merit and rigorous testing against engineering reality.

    +

    Our Philosophy & Approach

    +

    We believe that great software is built through open dialogue, collective wisdom, and a commitment to quality. Our projects grow from transparent design discussions, where ideas are polished through collaborative peer feedback and tested against real-world utility.

    - For Collaborators + For Our Community

    -

    Contributions require structured framing and formal design documentation. Proposals undergo a critical evaluation process prioritizing precision and feasibility.

    +

    We welcome dreamers, tinkers, and builders. Whether you're writing code, designing interfaces, or drafting documentation, Yutila is a collaborative space where every voice is heard and every contribution is valued.

    • - Structured Framing: Every project must originate from a formal Design Document that explicitly defines problems, constraints, and solutions. + Collaborative Design: We begin our projects with open design documents, inviting the community to brainstorm, share insights, and shape the architecture together from day one.
    • - Critical Evaluation: Proposals undergo a review process prioritizing precision, feasibility, and identifying trade-offs over reflexive validation. + Thoughtful Feedback: We hold thorough and constructive peer reviews, not to gatekeep, but to learn from each other and build systems that stand the test of time.
    • - Open Design: Contributors operate under "Open Design", ensuring all architectural decisions are transparent, documented, and built for interoperability. + Absolute Transparency: All architectural decisions, source code, and design processes are completely open to the public, ensuring true digital sovereignty.
    @@ -69,33 +69,33 @@ import PageHeader from '../components/PageHeader.astro';

    - For Investors + For Trust & Sovereignty

    -

    Development aligns with strict security adherence, standardized SecOps compliance and deterministic transaction stability.

    +

    We build with an unwavering commitment to user privacy, individual autonomy, and absolute security. Your data belongs to you, and your systems should be under your control, always.

    • - Strict Security Adherence: Projects must incorporate core principles: Fail-Safe Defaults, Least Privilege, and Open Design. + Security by Default: We design our systems to protect you out of the box, employing defensive engineering, minimal data collection, and open security audits.
    • - Standardized SecOps Compliance: Proposals must align with the Yutila Security Policies and satisfy rigorous testing requirements. + Privacy is a Human Right: We bake data minimization and tracking prevention into every line of code. We believe you shouldn't have to trade your privacy for utility.
    • - Deterministic Reliability: We prioritize backward compatibility and transaction stability, ensuring hosted projects run undisturbed in mission-critical environments. + Unyielding Independence: Our software is built to last, completely free of corporate backdoors, telemetry, or vendor lock-in. You own your software and hardware.
    -

    This governance-led approach ensures every project scales with the engineering rigor and security expected of a professional enterprise.

    +

    This community-first philosophy ensures that we build reliable, secure, and respectful technology that empowers people, protects fundamental freedoms, and stands strong against corporate overreach.

    @@ -111,6 +111,7 @@ import PageHeader from '../components/PageHeader.astro'; color: var(--text-color); opacity: 0.9; max-width: 800px; + text-align: justify; } .content-section { @@ -139,6 +140,7 @@ import PageHeader from '../components/PageHeader.astro'; color: var(--text-muted); line-height: 1.7; margin: 0 0 1rem 0; + text-align: justify; } .glass-card p:last-child { diff --git a/src/pages/governance.astro b/src/pages/governance.astro index f7de7cd..a4cd815 100644 --- a/src/pages/governance.astro +++ b/src/pages/governance.astro @@ -148,6 +148,7 @@ import PageHeader from '../components/PageHeader.astro'; line-height: 1.6; margin: 0; flex: 1; + text-align: justify; } .roles-cta { @@ -181,6 +182,7 @@ import PageHeader from '../components/PageHeader.astro'; max-width: 700px; margin: 0; line-height: 1.6; + text-align: justify; } .btn-primary { diff --git a/src/pages/index.astro b/src/pages/index.astro index 6b66fc8..e2441c1 100644 --- a/src/pages/index.astro +++ b/src/pages/index.astro @@ -47,7 +47,28 @@ const icons = [ Yutila -

    A technical collective focused on the engineering of software and interactive media and hardware infrastructure.

    +

    An independent community of developers crafting open-source software, interactive media, and hardware built on privacy, security, and digital freedom.

    + +
    +
    + + OpenChain Conformance Badge + +
    +
    + + + + + + +
    +
    +
    + ISO/IEC 5230 Conformant + Self-certified for open source license compliance +
    +
    @@ -77,6 +98,87 @@ const icons = [ line-height: 1.6; margin: 0; max-width: 600px; + text-align: justify; + } + + .conformance-badge { + margin-top: 3.5rem; + display: flex; + flex-direction: column; + align-items: flex-start; + gap: 1rem; + background: rgba(255, 255, 255, 0.02); + border: 1px solid rgba(255, 255, 255, 0.05); + padding: 1.25rem 1.5rem; + border-radius: 16px; + backdrop-filter: blur(12px); + box-shadow: 0 4px 30px rgba(0, 0, 0, 0.2); + transition: border-color 0.3s ease, background-color 0.3s ease; + } + + .conformance-badge:hover { + border-color: rgba(255, 255, 255, 0.08); + background: rgba(255, 255, 255, 0.03); + } + + .badge-row { + display: flex; + align-items: center; + gap: 1.25rem; + } + + .openchain-link img { + display: block; + transition: transform 0.25s cubic-bezier(0.175, 0.885, 0.32, 1.275); + } + + .openchain-link:hover img { + transform: scale(1.05) rotate(2deg); + } + + .logo-divider { + width: 1px; + height: 48px; + background: linear-gradient(to bottom, rgba(255, 255, 255, 0), rgba(255, 255, 255, 0.15), rgba(255, 255, 255, 0)); + } + + .standards-logos { + display: flex; + align-items: center; + gap: 0.75rem; + } + + .standard-logo { + display: block; + border-radius: 6px; + transition: transform 0.2s ease, filter 0.2s ease; + filter: grayscale(0.2) opacity(0.85); + } + + .standards-logos a:hover .standard-logo { + transform: translateY(-2px); + filter: grayscale(0) opacity(1); + } + + .badge-info { + display: flex; + flex-direction: column; + gap: 0.25rem; + } + + .badge-title { + font-size: 0.9rem; + color: var(--text-normal, #e4e4e7); + font-weight: 600; + text-transform: uppercase; + letter-spacing: 0.06em; + } + + .badge-desc { + font-size: 0.8rem; + color: var(--text-muted); + opacity: 0.85; + font-weight: 400; } .icon-field { From d269b986a4c78408c0d38b7e49eeede9697d3b54 Mon Sep 17 00:00:00 2001 From: Acrilic Date: Sun, 24 May 2026 10:59:37 +0200 Subject: [PATCH 22/22] docs: align camelot text with strict technical taxonomy and preserve simplified layout --- src/pages/docs/camelot/core/io.md | 16 ++--- src/pages/docs/camelot/core/merlin.md | 4 +- .../docs/camelot/overview/architecture.md | 8 +-- src/pages/docs/camelot/overview/index.md | 68 ++++++++++--------- src/pages/docs/camelot/overview/memory.md | 10 +-- src/pages/software/camelot.astro | 18 ++--- 6 files changed, 62 insertions(+), 62 deletions(-) diff --git a/src/pages/docs/camelot/core/io.md b/src/pages/docs/camelot/core/io.md index a13de17..1ee9d83 100644 --- a/src/pages/docs/camelot/core/io.md +++ b/src/pages/docs/camelot/core/io.md @@ -1,14 +1,14 @@ --- layout: ../../../../layouts/CamelotDocsLayout.astro title: I/O Utilities -description: Camelot's I/O subsystem — file operations, safe string interop, and platform abstraction. +description: Camelot's I/O subsystem — file operations, safe string interop and platform abstraction. --- The I/O subsystem provides a platform-agnostic abstraction layer that wraps POSIX and Windows APIs into Camelot's `Result` tri-state error model. All operations route through the `Allocator` VTable to maintain memory lifetime ownership. ## File Operations -Direct interaction with POSIX or Windows APIs creates platform-specific memory leaks, file descriptor leaks, and inconsistent error codes. Camelot's I/O module wraps these behind a clean, `Result`-returning interface: +Direct interaction with POSIX or Windows APIs creates platform-specific memory leaks, file descriptor leaks and inconsistent error codes. Camelot's I/O module wraps these behind a clean, `Result`-returning interface: ```c Result IO_read(Allocator* alloc, String path); @@ -18,7 +18,7 @@ Result IO_write(Allocator* alloc, String path, Slice data); Both functions: - Accept an `Allocator*` for any internal memory needs (e.g., read buffers) -- Return a `Result` with `OK` (success payload), `NIL` (no data), or `ERR` (system failure with domain-prefixed error code) +- Return a `Result` with `OK` (success payload), `NIL` (no data) or `ERR` (system failure with domain-prefixed error code) - Use the **Explicit Deferral** pattern (`goto defer`) to ensure all resources are freed on every exit path ### Error Mapping @@ -33,7 +33,7 @@ This ensures client code never needs to inspect raw `errno` values or POSIX/Wind ## Safe String Interoperability -When Camelot `String` values (non-owning slices) cross into libc boundaries (e.g., file paths for `fopen`), developers typically resort to `strcpy` or `sprintf`, reintroducing overflow risk. Camelot solves this with allocator-aware string construction: +When Camelot `String` values (non-owning slices) cross into libc boundaries (e.g., file paths for `fopen`), developers typically resort to `strcpy` or `sprintf` and reintroduce overflow risk. Camelot solves this with allocator-aware string construction: ### OwnedString @@ -108,7 +108,7 @@ if (res.status == RESULT_OK) { Result IO_write(Allocator* alloc, String path, Slice data); ``` -**Summary**: Safely writes a slice of bytes to a file. Overwrites the file if it exists, or creates it if it does not. +**Summary**: Safely writes a slice of bytes to a file. Overwrites the file if it exists or creates it if it does not. - **Parameters**: - `alloc` (`Allocator*`): The allocator used for any internal temporary buffers. @@ -135,14 +135,14 @@ Result res = IO_write(arena, STRING("output.txt"), data); [[nodiscard]] Result STRING_format(Allocator* alloc, const char* fmt, ...); ``` -**Summary**: Allocator-aware string formatting utility. Acts as a memory-safe alternative to `asprintf`, preventing double-frees and unmanaged memory. +**Summary**: Allocator-aware string formatting utility. Acts as a structural alternative to `asprintf`, preventing double-frees and unmanaged memory. - **Parameters**: - `alloc` (`Allocator*`): The allocator to provision the resulting string. - `fmt` (`const char*`): A standard `printf`-style format string. - `...`: Variadic arguments matching the format specifiers. - **Returns**: `Result` containing an `OwnedString*` payload on success. -- **Errors**: Returns `ERR_MEMORY_ERROR` if allocation fails, or `ERR_FORMAT_ERROR` on encoding issues. +- **Errors**: Returns `ERR_MEMORY_ERROR` if allocation fails or `ERR_FORMAT_ERROR` on encoding issues. - **See Also**: [`OWNEDSTRING_deinit`](#ownedstring_deinit), [`STRING_formatVariadic`](#string_formatvariadic)
    @@ -184,7 +184,7 @@ void OWNEDSTRING_deinit(OwnedString* str); - **Parameters**: - `str` (`OwnedString*`): A pointer to the owned string to destroy. If `NULL`, the function is a no-op. -- **Side Effects**: The memory underlying `str->view` is freed, and the `str` struct itself is destroyed. +- **Side Effects**: The memory underlying `str->view` is freed and the `str` struct itself is destroyed. - **See Also**: [`STRING_format`](#string_format) diff --git a/src/pages/docs/camelot/core/merlin.md b/src/pages/docs/camelot/core/merlin.md index 4e4e959..42fe6f9 100644 --- a/src/pages/docs/camelot/core/merlin.md +++ b/src/pages/docs/camelot/core/merlin.md @@ -1,10 +1,10 @@ --- layout: ../../../../layouts/CamelotDocsLayout.astro title: Merlin Build Engine -description: The Merlin TUI build orchestrator — architecture, compiler detection, and CI/CD integration. +description: The Merlin TUI build orchestrator — architecture, compiler detection and CI/CD integration. --- -Merlin is the singular, monolithic build engine for the Camelot framework, written in the **D programming language**. It replaces traditional Makefiles and CMake with an intelligent, dynamically animated TUI supervisor. +Merlin is the singular build engine for the Camelot toolkit, written in the **D programming language**. It replaces traditional Makefiles and CMake with an interactive TUI supervisor. ## Why D? diff --git a/src/pages/docs/camelot/overview/architecture.md b/src/pages/docs/camelot/overview/architecture.md index bba1a78..86bd339 100644 --- a/src/pages/docs/camelot/overview/architecture.md +++ b/src/pages/docs/camelot/overview/architecture.md @@ -1,10 +1,10 @@ --- layout: ../../../../layouts/CamelotDocsLayout.astro title: Architecture -description: The full architectural design of Camelot — VTable dispatch, module hierarchy, and data flow. +description: The full architectural design of Camelot — VTable dispatch, module hierarchy and data flow. --- -The architecture of the Camelot ecosystem is split into two distinct tiers: **the Orchestrator** (Merlin, in D) and **the Framework** (Camelot, in C23). Together they form a complete, self-contained development platform. +The architecture of the Camelot ecosystem is split into two distinct tiers: **the Orchestrator** (Merlin, in D) and **the Toolkit** (Camelot, in C23). Together they form a self-contained development platform. ## Allocator Agnosticism (VTable) @@ -18,13 +18,13 @@ struct Allocator { }; ``` -Hardcoding `malloc` and `free` throughout a codebase creates rigid structures. The VTable solves this by allowing any Camelot type to be instantiated with a heap allocator, a local arena, or a stack buffer — remaining completely agnostic to where the memory actually comes from. +Hardcoding `malloc` and `free` throughout a codebase creates rigid structures. The VTable solves this by allowing any Camelot type to be instantiated with a heap allocator, a local arena or a stack buffer — remaining completely agnostic to where the memory actually comes from. This means the same `Vector` or `Table` can operate on heap memory in production and on a fixed arena in tests, without changing a single line of its internal logic. ## Result Type (Tri-State Error Model) -Standard C lacks mechanisms to enforce return value checking, and frequently conflates expected logic branching (e.g., a missing table key) with systemic failures (e.g., out-of-memory). Camelot solves this with a tri-state tagged union: +Standard C lacks mechanisms to enforce return value checking and frequently conflates expected logic branching (e.g., a missing table key) with systemic failures (e.g., out-of-memory). Camelot solves this with a tri-state tagged union: ```c typedef enum { diff --git a/src/pages/docs/camelot/overview/index.md b/src/pages/docs/camelot/overview/index.md index b97f634..6f64b60 100644 --- a/src/pages/docs/camelot/overview/index.md +++ b/src/pages/docs/camelot/overview/index.md @@ -1,70 +1,74 @@ --- layout: ../../../../layouts/CamelotDocsLayout.astro title: Introduction -description: A quick look at the Camelot framework. +description: Overview of the Camelot C23 core toolkit — its design philosophy, component model and the Merlin build orchestrator. --- -Camelot is a C framework that focuses on memory safety and predictable behavior under C23. It utilizes its own build tool called **Merlin** (written in D). +Camelot is a core systems component toolkit engineered for predictable execution under the C23 standard. It is orchestrated by **Merlin**, a custom build engine written in the D programming language. -Instead of relying on `malloc` directly and risking memory leaks, Camelot provides memory arenas. It includes basic data structures and error handling, remaining fully compatible across GCC, Clang, and MSVC. +The toolkit provides structural alternatives to libc subsystems featuring explicit allocator boundaries, localized memory arenas, a tri-state error model and strict compiler defaults — all while remaining fully portable across GCC, Clang and MSVC. -## Motivation +## Design Philosophy -The framework was engineered to be straightforward to read, robust against unexpected failures, and portable without requiring complex build environments. Straightforward semantics are prioritized over syntactic sugar. +### Predictable Systems (The Mechanism Paradigm) + +Camelot prioritizes explicit mechanism, cross-platform interoperability and traceable state transitions over implicit syntax. Camelot's abstractions are engineered to be predictably robust, structurally transparent and rigorously tested so they can run undisturbed in constrained environments. ### Naming Convention -All functions follow a strict `DOMAIN_functionSubfunction` naming style to ensure intent is immediately recognizable: +All functions strictly utilize the `DOMAIN_functionSubfunction` format: + +- **Domain prefix**: Fully uppercase (e.g., `ARENA`, `VECTOR`, `STRING`) +- **Primary function name**: Fully lowercase +- **Subfunction qualifier**: Appended in camelCase without additional underscores -- **Domain prefix**: Always uppercase (e.g., `ARENA`, `VECTOR`, `STRING`) -- **Primary function name**: Always lowercase -- **Subfunction qualifier**: Added in camelCase with no extra underscores +Word truncations or casual abbreviations are prohibited unless using universally standard acronyms (e.g., `IO`). -Arbitrary abbreviations are avoided unless they are universally recognized (such as `IO`). +### Portability & Compiler Extensions -### Portability Guidelines +To guarantee absolute portability across arbitrary C compilers, reliance on non-standard runtime compiler extensions is explicitly prohibited. -Reliance on non-standard compiler extensions that alter runtime execution is explicitly avoided. -- Compile-time annotations (like `__attribute__((warn_unused_result))`) are permitted. -- Behavior-altering extensions (like GCC's `cleanup` attribute) are prohibited due to a lack of universal support. +- Compiler attributes that operate strictly during compilation (e.g., `__attribute__((warn_unused_result))`) are acceptable. +- Runtime-altering extensions, specifically GCC's `__attribute__((cleanup))` for RAII emulation, are **forbidden** due to lack of support in non-GNU environments. ## Project Structure ```text camelot/ -├── include/ # Public APIs -│ └── camelot/ -│ ├── core/ -│ ├── memory/ -│ ├── types/ -│ └── camelot.h # Main header -├── src/ # Implementation +├── include/ # Public API Headers (read-only for clients) +│ └── camelot/ # Unified namespace +│ ├── core/ # Fundamental abstractions (Result, Safety) +│ ├── memory/ # Memory management (Arena, Allocator) +│ ├── types/ # Primitives and String types +│ └── camelot.h # Umbrella header for full framework access +├── src/ # Private Implementation (.c files) │ ├── core/ │ ├── memory/ │ ├── io/ │ ├── ds/ │ └── types/ -├── tests/ # Test suites -├── merlin.d # Merlin build orchestrator -├── Makefile # Bootstrap for Merlin -└── README.md +├── tests/ # Unit and Integration Testing suite +├── merlin.d # Merlin Build Orchestrator (D language) +├── Makefile # Bootstrap entry point for Merlin +└── README.md # Project entry point ``` -### Architectural Principles +### Architectural Rationale -1. **Isolation**: Headers in `include/camelot/` define the public interface. Implementations remain isolated in `src/`. -2. **Mirroring**: The `src/` directory exactly mirrors the `include/` directory structure. -3. **Flat Namespace**: All headers are nested under the `camelot/` directory to prevent collisions. +1. **Public/Private Isolation**: Headers in `include/camelot/` ensure only intended APIs are accessible via `#include `. Private headers remain within `src/`. +2. **Namespace Mirroring**: The `src/` directory mirrors `include/` exactly, predictably mapping implementation files to their corresponding headers. +3. **Modular Compilation**: Every module compiles into an independent object file, enabling the linker to prune unused modules in static builds. +4. **Flat Namespace**: All headers are accessed through the `camelot/` prefix to prevent header collision in large projects. -## Usage +## Unified Header -Include the primary header file: +Including the entire framework is a single line: ```c #include ``` -This single inclusion provides access to the entire framework. +This umbrella header transitively includes all subsystems: primitives, allocators, arenas, result types and the safety header. ## License diff --git a/src/pages/docs/camelot/overview/memory.md b/src/pages/docs/camelot/overview/memory.md index d45b91b..37a9a9b 100644 --- a/src/pages/docs/camelot/overview/memory.md +++ b/src/pages/docs/camelot/overview/memory.md @@ -1,14 +1,14 @@ --- layout: ../../../../layouts/CamelotDocsLayout.astro title: Memory Allocator -description: Camelot's Arena memory allocator — design, implementation, and usage patterns. +description: Camelot's Arena memory allocator — design, implementation and usage patterns. --- Camelot's memory subsystem is built around two core abstractions: the **Allocator VTable** (a generic dispatch interface) and the **Arena** (a concrete, high-performance implementation of that interface). ## The Problem -Tracking and freeing thousands of individual object allocations leads to memory fragmentation, high CPU overhead, and inevitable memory leaks when a single `free()` is forgotten. Additionally, hardcoding `malloc` prevents swapping memory strategies for testing or restricted environments. +Tracking and freeing thousands of individual object allocations leads to memory fragmentation, high CPU overhead and inevitable memory leaks when a single `free()` is forgotten. Additionally, hardcoding `malloc` prevents swapping memory strategies for testing or restricted environments. ## Allocator VTable @@ -81,7 +81,7 @@ void ARENA_reset(Arena* self) { } ``` -This single operation invalidates all prior allocations instantaneously, making arenas ideal for per-frame, per-request, or per-transaction memory patterns. +This single operation invalidates all prior allocations instantaneously, making arenas ideal for per-frame, per-request or per-transaction memory patterns. ### Memory Layout Visualization @@ -113,11 +113,11 @@ The following data structures are specified in the Software Design Document and |---|---|---|---| | `Vector` | Dynamic array | 1.5x bitwise (`cap + (cap >> 1)`) | Memory-recyclable growth | | `LIST` | Doubly linked list | Per-node | Pointer-stable O(1) insertion | -| `Table` | Swiss Table hash map | Power-of-2 | SIMD-friendly metadata probing | +| `Table` | Hash map (open addressing) | Power-of-2 | SIMD-friendly metadata probing | | `Slice` | Fat pointer view | N/A (non-owning) | Zero-copy memory access | | `String` | Text slice (`typedef Slice`) | N/A (non-owning) | O(1) length, no null terminator | | `OwnedString` | Allocator-paired string | Allocator-aware | Explicit Deinit compliant | ### Vector Growth: Why 1.5x -The Vector uses a mathematically proven **1.5x capacity growth multiplier** (`cap = cap + (cap >> 1)`). By growing at exactly 1.5x instead of the industry standard 2.0x, the sum of all previously discarded block allocations will eventually exceed the next requested capacity. Once this threshold is crossed, the allocator can coalesce and recycle the older blocks, achieving optimal memory reduction without manual tuning. +The Vector uses a **1.5x capacity growth multiplier** (`cap = cap + (cap >> 1)`). By growing at exactly 1.5x instead of the industry standard 2.0x, the sum of all previously discarded block allocations will eventually exceed the next requested capacity. Once this threshold is crossed, it permits block recycling by the host allocator. diff --git a/src/pages/software/camelot.astro b/src/pages/software/camelot.astro index 8888bf1..5ce8988 100644 --- a/src/pages/software/camelot.astro +++ b/src/pages/software/camelot.astro @@ -99,11 +99,7 @@ import '../../styles/camelot-docs.css';

    - Camelot is a C framework structured for predictable memory execution under C23. - It utilizes memory arenas in place of arbitrary malloc calls, implements its own standard data structures, and is orchestrated by a dedicated build engine (Merlin). -

    -

    - The architecture emphasizes absolute control over the runtime environment, eschewing magic and unpredictable latency spikes. + Camelot is a core component toolkit for C applications. It provides structural alternatives to libc subsystems that expose implicit allocation behavior, utilizing memory arenas and strict compiler flags orchestrated by the Merlin build engine.

    @@ -144,28 +140,28 @@ make
    - + - + - +
    - Build Engine + Merlin Orchestrator
    		A dedicated build orchestrator written in D named Merlin. It handles compiler flags, sanitizers, and compilation automatically, removing the need for external build systems.Driven by Merlin, a standalone D build engine that dynamically manages GCC compilation, sanitizers and parallel workflows.
    - Memory Allocation + Memory Arenas
    		Dynamic memory is strictly managed through arenas. This guarantees O(1) allocation times and structurally eliminates traditional memory leaks.Requires explicit allocator pointers instead of unmanaged `malloc`. Features localized memory arenas for predictable memory management without implicit allocations.
    - Security + Strict Defaults
    		Projects are compiled with stack protectors, PIE, and ASAN/UBSAN to intercept common memory faults during execution.Compiled automatically with PIE, stack protection and ASAN/UBSAN sanitizers to systematically constrain undefined behavior.