BranchesTags

Repository files navigation

Flow Kernel

Kernel CIDiagnosticsGitHub Pages

Flow systems integration on top of a deliberately tiny Linux base.

flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.

Architecture

Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.

Repository boundary

flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.

Fetch the Tiny Core base

The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.

bash tinycore/fetch.sh

Artifacts are placed under build/tinycore/.

Boot it

bash tinycore/run.sh

This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.

Deterministic system-health sequence

A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:

kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.

The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.

Verification

CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.

Flow compiler

Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.

Roadmap

The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.

About

No description, website, or topics provided.

Resources

Readme
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Flow Kernel
Kernel CIDiagnosticsGitHub Pages
Flow systems integration on top of a deliberately tiny Linux base.
flow-kernel no longer implements its own bootloader, page tables, scheduler, interrupt subsystem, or virtual-memory manager. Those are Linux responsibilities. The base target is Tiny Core Linux CorePure64: a minimal command-line Linux system that gives Flow a mature x86_64 kernel, drivers, networking, processes, namespaces, cgroups, perf and the native Linux eBPF surface without dragging in a conventional desktop distribution.
Architecture
Linux kernel
↑
Tiny Core CorePure64 userspace
↑
Flow system services / kernel-facing components
↑
Flow eBPF, XDP, tracing and driver experiments

Tiny Core is the substrate, not a fork. We consume its vmlinuz64 and corepure64.gz release artifacts directly.
Repository boundary
flooooooooooow/flow owns language syntax, parser/type-system behaviour, generic compiler infrastructure and reusable target/backend machinery. flow-kernel owns Linux-specific ABI bindings, kernel-facing Flow libraries, eBPF program APIs and examples, loaders/control-plane code, Tiny Core packaging, kernel integration tests and systems benchmarks. Changes needed in the Flow compiler should be implemented upstream rather than copied into this repository.
Fetch the Tiny Core base
The default tracks Tiny Core CorePure64 17.1 with Linux 6.18.35-tinycore64. The fetch script tries configured public mirrors, verifies Tiny Core's published MD5 sidecars, and records a manifest containing the exact version, source mirror and checksums used.
bash tinycore/fetch.sh
Artifacts are placed under build/tinycore/.
Boot it
bash tinycore/run.sh
This boots the Tiny Core Linux kernel and initramfs directly in QEMU with the serial console attached to the terminal. No GRUB image and no Flow-owned architecture bootstrap are involved.
Deterministic system-health sequence
A successful boot is not treated as a single boolean. CI runs an ordered diagnostic PID 1 and validates the system as a state machine:
kernel → initramfs → PID 1 → procfs → sysfs → devices → writable state
→ CPU → memory → timer → RNG → processes → signals → pipes → filesystem
→ block devices → network → DNS → namespaces → cgroups → BPF → Flow → complete

Every guest stage emits a stable serial marker and monotonic timestamp. The host verifier rejects missing/out-of-order required stages, kernel panic/oops/BUG/rootfs/init-failure signatures, and non-monotonic timing. Environment-dependent checks such as DNS, block-device presence and cgroups can report advisory degradation without being confused with boot failure.
The generated boot-health.json records the overall health state, last known-good stage, per-stage timings, failures/degradation, and evidence such as kernel release, CPU count, RAM, entropy, block devices and network interfaces. A separate QEMU lifecycle probe verifies the guest reboot path. See diagnostics/README.md.
Verification
CI caches the Tiny Core base, revalidates the published checksum sidecars, records the exact source/version/checksums, captures serial boot logs, exercises the full system-health sequence, verifies a libc-free Flow executable inside the guest, validates reboot behaviour, and archives the resulting health/evidence reports. The eBPF/BTF feature set is checked from the real Tiny Core kernel config when that metadata is available instead of inferred from the Linux version.
Flow compiler
Flow remains a separate dependency. Kernel-facing Flow programs in this repository should compile against Linux ABIs or to eBPF; the language/compiler belongs in flooooooooooow/flow and is checked out independently in CI.
Roadmap
The next work is deliberately Linux-native: finish the Flow-to-eBPF verifier path, BTF-aware bindings, maps, verifier-safe helpers, tracepoint/kprobe hooks, XDP, TC hooks and eventually CO-RE-style relocatable programs. User-space Flow services can remain tiny and run directly on CorePure64.
About
No description, website, or topics provided.
Resources
Readme
Activity
Custom properties
Stars
1 star
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages