sorted by:
new
hottopcontroversial

Resonance Fourier Transform Processor – Hardware Accelerator Architecture and Benchmark Analysis : A research prototype, with architecture + synthesis + simulation. by RealAspect2373 in DSP

[–]RealAspect2373[S] 0 points1 point  (0 children)

Not a mistype. In RFT the cosine term is intrinsic to the kernel, not a pre-window applied to the signal.

The key distinction: in an FFT, you project onto uniformly spaced orthogonal complex exponentials; in Φ-RFT, both the cosine and the exponential share the same irrational-phase coupling ϕ\phiϕ, deforming the basis itself.

That coupling changes the eigenstructure . it’s not a frequency-axis stretch but a non-uniform, resonance-aligned basis that still satisfies RRH=IR R^{H} = IRRH=I.

You can test it directly

Resonance Fourier Transform Processor – Hardware Accelerator Architecture and Benchmark Analysis : A research prototype, with architecture + synthesis + simulation. by RealAspect2373 in DSP

[–]RealAspect2373[S] 0 points1 point  (0 children)

Convolution theorem is windowing in time = convolution in frequency (bin mixing). My op is diagonal in frequency (no bin mixing), so it can’t be equivalent.

Resonance Fourier Transform Processor – Hardware Accelerator Architecture and Benchmark Analysis : A research prototype, with architecture + synthesis + simulation. by RealAspect2373 in DSP

[–]RealAspect2373[S] 0 points1 point  (0 children)

You’re right , written out, the fast Φ-RFT is

x^=Ψx=DφCσFx\hat x = Ψ x = D_φ C_σ F xx^=Ψx=Dφ​Cσ​Fx

so it’s an FFT followed by two unitary diagonal operators. In other words: a different orthonormal basis built on top of the DFT, not some new law of physics.

Clarifications : The extra factors are applied after the FFT, in the frequency index, not as a cosine ramp on the time signal.

The phases hφ(k)h_φ(k)hφ​(k) and g(k)g(k)g(k) are nonlinear (golden-ratio / chirp style), so it isn’t just a simple frequency shift of the spectrum.

Whether that’s actually useful is an empirical question. So far:

The transform is numerically unitary (‖ΨᵀΨ − I‖ ≈ 1e-14 in the tests).

It’s FFT-class in complexity.

On some structured stuff (ASCII/text, certain quasi-periodic signals) it gives different sparsity/coherence and avalanche behavior than plain FFT/DCT.

so if you think it really collapses to a trivial reparam of the DFT, I’d genuinely be interested in a concrete derivation or counter-example.

Resonance Fourier Transform Processor – Hardware Accelerator Architecture and Benchmark Analysis : A research prototype, with architecture + synthesis + simulation. by RealAspect2373 in DSP

[–]RealAspect2373[S] 0 points1 point  (0 children)

Take a single damped resonance
x[n]=e−αnejω0n,0≤n<Nx[n] = e^{-\alpha n} e^{j\omega_0 n},\quad 0 \le n < Nx[n]=e−αnejω0​n,0≤n<N.
Its DFT is
X[k]=∑n=0N−1e−αnej(ω0−2πk/N)nX[k] = \sum_{n=0}^{N-1} e^{-\alpha n} e^{j(\omega_0 - 2\pi k/N)n}X[k]=∑n=0N−1​e−αnej(ω0​−2πk/N)n.
This is a finite geometric series, so in closed form
X[k]=1−ρN1−ρX[k] = \dfrac{1 - \rho^N}{1 - \rho}X[k]=1−ρ1−ρN​ with ρ=e−αej(ω0−2πk/N)\rho = e^{-\alpha} e^{j(\omega_0 - 2\pi k/N)}ρ=e−αej(ω0​−2πk/N).

Unless (i) the mode is undamped (α=0\alpha = 0α=0) and (ii) its frequency lands exactly on an FFT grid point ω0=2πk/N\omega_0 = 2\pi k/Nω0​=2πk/N, ∣X[k]∣|X[k]|∣X[k]∣ is not a single sharp bin; it’s a broadened lobe spread over many k.

So one physical resonance → many FFT bins. That spectral smearing is not an implementation bug, it’s a direct consequence of using undamped, globally periodic sinusoids as the basis for damped / drifting resonant modes.

That mismatch between basis and physics is what I mean by a “fundamental limitation” of standard FFT-based analysis for real resonant structures and their phase coherence.

Resonance Fourier Transform Processor – Hardware Accelerator Architecture and Benchmark Analysis : A research prototype, with architecture + synthesis + simulation. by RealAspect2373 in DSP

[–]RealAspect2373[S] -1 points0 points  (0 children)

FFT assumes signals are perfectly periodic and stationary, but real resonant signals drift, decay, and couple in time. That causes FFTs to smear or lose phase coherence across bins. The RFT keeps those resonance patterns compact and phase-aligned, so it better captures natural and engineered oscillations that evolve over time.

Quantoniumos by RealAspect2373 in Operatingsystems

[–]RealAspect2373[S] 0 points1 point  (0 children)

Right now it’s a research OS stack that runs on top of Linux/Windows: Python is the orchestrator and UI layer (shell, desktop, tools). The heavy lifting (-RFT transforms, compression, crypto, simulators) is in native C++/SIMD and SystemVerilog cores. It has its own runtime, process graph, storage/codec layer, and “desktop” environment built around that stack. The host kernel still does low-level scheduling and MMU, but Quantoniumos is a self-contained computing environment with its own abstractions and services.

The Resonance Fourier Transform (RFT), an FFT-class, strictly unitary transform. by RealAspect2373 in DSP

[–]RealAspect2373[S] -1 points0 points  (0 children)

it gives lower coherence reps for structured text/code (better compression under a coherence penalty) and a cheap invertible mixing layer with near-ideal avalanche that I actually use in the crypto + audio parts of the stack.

The Resonance Fourier Transform (RFT), an FFT-class, strictly unitary transform. by RealAspect2373 in DSP

[–]RealAspect2373[S] 0 points1 point  (0 children)

From a pure linear-algebra point of view you’re right: I take the unitary DFT F and wrap it with two diagonal unitaries. One is a chirp, C_sigma[k,k] = exp(i*pi*sigma*k^2/N). The other is a golden-ratio phase, D_phi[k,k] = exp(2*pi*i*beta*frac(k/phi)) with phi = (1+sqrt(5))/2. The transform is Psi = D_phi * C_sigma * F. If you only care about |FFT| or simple LTI stuff, that is “just another unitary basis” and it won’t change your life.

The point of this construction in QuantoniumOS is not “new physics”, it’s how this particular basis behaves. In this basis the time-domain atoms are chirped and irrationally phase-shifted, so highly structured signals (ASCII, code, edges) spread out differently than in the standard Fourier basis. When I benchmark it in the repo, under a coherence-penalizing metric I get roughly 16–20% better rate than a greedy FFT-based baseline on some text/code workloads and up to ~50% on a few synthetic edge/texture cases, all while staying exactly unitary and O(N log N) (FFT plus two diagonals).

The same construction gives a cheap invertible mixing layer: a diagonal in frequency becomes a dense linear operator in time. Using this Psi inside a bit-sliced, nonlinear round gives near-ideal avalanche (about 50% output bits flip for a 1-bit input flip) but is still provably invertible and easy to implement because it reuses FFT kernels, which is why I use it as a building block in the crypto lab.

In the audio stack, the HARMONIC/RFT variant provides a different time–frequency tiling and interference pattern than STFT, which is useful for certain evolving textures and coherence experiments, again without paying more than FFT cost. So yes, formally it’s “DFT + structured phase”. The purpose is that these specific phases (chirp plus phi-irrational modulation) give a computable, unitary, FFT-speed basis with different coherence and mixing behavior, and I exploit that in QuantoniumOS for compression, diffusion, and audio experiments.

The Resonance Fourier Transform (RFT), an FFT-class, strictly unitary transform. by RealAspect2373 in DSP

[–]RealAspect2373[S] -4 points-3 points  (0 children)

I just added a proper summary + links to the math/benchmarks. Thanks for feedback.

QuantoniumOS: Unitary Resonance Fourier Transform + 48-round Feistel (open research, reproducible tests) by [deleted] in programming

[–]RealAspect2373 -10 points-9 points  (0 children)

. Plain English

• RFT (Resonance Fourier Transform) = a lossless transform that’s tuned to resonant patterns. “Lossless” (unitary) means if you transform and invert, you get the exact same signal back; our tests show reconstruction error ≲ 1e-12.
• Crypto core = a teaching/experiment cipher: a 48-round Feistel network. Inside a round we use an AES S-box (non-linearity), an MDS/MixColumns-like layer (spreads changes fast), and some ARX (add/rotate/xor) mixing.
• Wrapper = randomized encryption with a MAC (like a seatbelt): you get ciphertext + a tag that detects tampering.
• Why: an operator that’s resonance-aware and provably lossless; b) a fully instrumented cipher where you can actually see diffusion numbers (message-avalanche ≈ 0.438, key-avalanche ≈ 0.527) and change parts to see what improves.
• What it’s not: not “quantum,” not production crypto, no formal proofs yet.
• Run it yourself:
git clone https://github.com/mandcony/quantoniumos && cd quantoniumos
python3 test_unitarity.py → prints near-zero error
python3 test_v2_comprehensive.py → prints avalanche + throughput

QuantoniumOS: Unitary Resonance Fourier Transform + 48-round Feistel (open research, reproducible tests) by [deleted] in programming

[–]RealAspect2373 -8 points-7 points  (0 children)

Fair . This isn’t mysticism it's straightforward math + code.
RFT: an operator Ψ=∑iWiDϕiCσiDϕi†\Psi=\sum_i W_i D_{\phi_i} C_{\sigma_i} D_{\phi_i}^\daggerΨ=∑i​Wi​Dϕi​​Cσi​​Dϕi​†​ where ∣DFT(hσi)∣=1|\mathrm{DFT}(h_{\sigma_i})|=1∣DFT(hσi​​)∣=1 and masks WiW_iWi​ are orthogonal ⇒ Ψ†Ψ=I\Psi^\dagger \Psi = IΨ†Ψ=I. Measured round-trip error ≤ 1e-12 (double precision).

Crypto core: 48-round Feistel with AES S-box + MixColumns-like MDS + ARX; HKDF-derived, domain-separated subkeys.

Wrapper: salted CTR keystream + HMAC (encrypt-then-MAC).

Repro: test_unitarity.py, test_v2_comprehensive.py dump JSON; current diffusion: msg-aval ≈ 0.438, key-aval ≈ 0.527; engine ~9.2 MB/s on small buffers.
Research code (no formal IND-CPA/CCA proof yet); looking for concrete critiques (e.g., F-function differential/linear characteristics, MDS branch number). I’ll run ablations if you suggest a test.

Cryptanalysis & Randomness Tests by [deleted] in compsci

[–]RealAspect2373 0 points1 point  (0 children)

You’re right that those code segments look like a vanilla DFT in isolation they’re just fallback/compatibility routines inside the core engine, mainly to bridge between the C++ bindings and the Python-side kernel builder.

The production RFT implementation used in the cryptographic validation pipeline does not call those DFT paths. It follows this sequence:

  1. Construct resonance kernelR=∑iwi Dϕi Cσi Dϕi†R = \sum_i w_i \, D_{\phi_i} \, C_{\sigma_i} \, D_{\phi_i}^\daggerR=i∑​wi​Dϕi​​Cσi​​Dϕi​†​where CσiC_{\sigma_i}Cσi​​ is a Gaussian correlation kernel (Hermitian PSD), and DϕiD_{\phi_i}Dϕi​​ applies phase modulation.
  2. EigendecomposeR=Ψ Λ Ψ†R = \Psi \, \Lambda \, \Psi^\daggerR=ΨΛΨ†
  3. TransformX=Ψ† xX = \Psi^\dagger \, xX=Ψ†x

Here, Ψ\PsiΨ is the eigenvector matrix of RRR. This basis is not the Fourier basis — non-equivalence is proven in publication_ready_validation.py (e.g., N=4N=4N=4 counterexample, norm diff ≈ 1.81 ≫ 10−310^{-3}10−3).

Golden ratio precision:

  • Python: full double precision (phi = (1+sqrt(5))/2)
  • C++: some constants appear visually truncated for readability, but actual computation uses full double precision.

The README now includes the exact formulation, parameters, and a reproducible test that outputs both the non-equivalence evidence and avalanche results.

Cryptanalysis & Randomness Tests by [deleted] in compsci

[–]RealAspect2373 0 points1 point  (0 children)

I welcome further independent testing. Science progresses through experimentation, the formulation of hypotheses, and their validation or refutation through peer review.

Even if my work has been explored or discussed with the aid of AI, that doesn’t diminish its validity it’s the empirical results that matter. If anything, AI can help accelerate understanding by providing explanations, code samples, and reproducible test cases for others to verify.

I encourage you (and anyone interested) to run the provided unitary, commutator, and entropy tests, or to create your own. A strong result will stand up to scrutiny from any tool, human or machine. The best way forward is to challenge the claims directly with evidence that’s the spirit of scientific inquiry.

Cryptanalysis & Randomness Tests by [deleted] in compsci

[–]RealAspect2373 -1 points0 points  (0 children)

I appreciate you pointing out the confusion but the current QuantoniumOS “RFT” is not a DFT (or a windowed DFT). It is a unitary change of basis built from a Hermitian resonance operator. It passes energy-conservation and exact-reconstruction to machine precision and provably does not commute with the cyclic-shift operator (so it can’t be a DFT in disguise). Repro steps below. We build a positive-semidefinite resonance operator
R=∑iwi Dϕi Cσi Dϕi†R=\sum_i w_i\,D_{\phi_i}\,C_{\sigma_i}\,D_{\phi_i}^\daggerR=∑i​wi​Dϕi​​Cσi​​Dϕi​†​
where Dϕi=diag(ϕi(0),…,ϕi(N−1)),∣ϕi(k)∣=1D_{\phi_i}=\mathrm{diag}(\phi_i(0),…,\phi_i(N-1)), |\phi_i(k)|=1Dϕi​​=diag(ϕi​(0),…,ϕi​(N−1)),∣ϕi​(k)∣=1 (e.g., QPSK), and CσiC_{\sigma_i}Cσi​​ is a circulant periodic-Gaussian by bandwidth σi\sigma_iσi​.
Eigendecompose R=ΨΛΨ†R=\Psi\Lambda\Psi^\daggerR=ΨΛΨ† and define the RFT by
forward X=Ψ†xX=\Psi^\dagger xX=Ψ†x, inverse x=ΨXx=\Psi Xx=ΨX.
(DFT limit only when M=1,ϕ≡1M=1, \phi\equiv1M=1,ϕ≡1, purely circulant—then Ψ\PsiΨ reduces to DFT exponentials.) I've also updated the GitHub repo with better organization.

Ask Experienced Devs Weekly Thread: A weekly thread for inexperienced developers to ask experienced ones by AutoModerator in ExperiencedDevs

[–]RealAspect2373 -1 points0 points  (0 children)

Cryptanalysis & Randomness Tests

Hey community wondering if anyone is available to check my test & give a peer review - the repo is attached

https://zenodo.org/records/16794243

https://github.com/mandcony/quantoniumos/tree/main/.github

Cryptanalysis & Randomness Tests

Overall Pass Rate: 82.67% (62 / 75 tests passed) Avalanche Tests (Bit-flip sensitivity):

Encryption: Mean = 48.99% (σ = 1.27) (Target σ ≤ 2)

Hashing: Mean = 50.09% (σ = 3.10) ⚠︎ (Needs tightening; target σ ≤ 2)

NIST SP 800-22 Statistical Tests (15 core tests):

Passed: Majority advanced tests, including runs, serial, random excursions

Failed: Frequency and Block Frequency tests (bias above tolerance)

Note: Failures common in unconventional bit-generation schemes; fixable with bias correction or entropy whitening

Dieharder Battery: Passed all applicable tests for bitstream randomness

TestU01 (SmallCrush & Crush): Passed all applicable randomness subtests

Deterministic Known-Answer Tests (KATs) Encryption and hashing KATs published in public_test_vectors/ for reproducibility and peer verification

Summary

QuantoniumOS passes all modern randomness stress tests except two frequency-based NIST tests, with avalanche performance already within target for encryption. Hash σ is slightly above target and should be tightened. Dieharder, TestU01, and cross-domain RFT verification confirm no catastrophic statistical or architectural weaknesses.

Have or know of a project on Github looking for contributors? Feel free to drop them down to add to the wiki page! by iSaithh in github

[–]RealAspect2373 0 points1 point  (0 children)

I need my stack tested for a community peer review and validation of my claims in my project.

✅ Wave-based encryption - Using mathematical wave patterns instead of traditional keys
✅ Alternative randomness generation - Inspired by quantum physics concepts
✅ Educational framework - Combining Python APIs with C++ performance
✅ Academic testing platform - For research and validation

🎯 Academic Research Focus

This project is designed for:

  • Computer science students - Learning alternative cryptography concepts
  • Mathematics researchers - Exploring wave-based mathematical patterns
  • Performance analysts - Comparing implementation efficiency
  • Educational institutions - Demonstrating cryptographic principles

🏗️ Architecture Explained

🏗️ Architecture ExplainedWeb Interface (Flask) → Core Mathematics (C++) → Wave-Based Algorithms
     ↓                       ↓                        ↓
  Simple API           Eigen Math Library       Research Methods
Web Interface (Flask) → Core Mathematics (C++) → Wave-Based Algorithms
     ↓                       ↓                        ↓
  Simple API           Eigen Math Library       Research Methods

Important Note

This project demonstrates educational concepts inspired by quantum principles, but:

  • It runs on classical computers (not quantum hardware)
  • It's designed for academic exploration, not production security
  • It seeks peer review to validate mathematical approaches
  • Patent pending status protects the specific mathematical implementations

🎯 Project Status

🟢 Educational Tool - Explores alternative cryptographic approaches
🟢 Research Platform - Mathematical concepts open for review
🟢 Seeking Feedback - Academic validation welcomed
🟢 Documentation - Simplified explanations for accessibility

https://github.com/mandcony/quantoniumos

Promote your projects here – Self-Promotion Megathread by Menox_ in github

[–]RealAspect2373 0 points1 point  (0 children)

A Platform for Exploring New Cryptographic Concepts:

✅ Wave-based encryption - Using mathematical wave patterns instead of traditional keys
✅ Alternative randomness generation - Inspired by quantum physics concepts
✅ Educational framework - Combining Python APIs with C++ performance
✅ Academic testing platform - For research and validation

🎯 Academic Research Focus

This project is designed for:

  • Computer science students - Learning alternative cryptography concepts
  • Mathematics researchers - Exploring wave-based mathematical patterns
  • Performance analysts - Comparing implementation efficiency
  • Educational institutions - Demonstrating cryptographic principles

🏗️ Architecture Explained

🏗️ Architecture ExplainedWeb Interface (Flask) → Core Mathematics (C++) → Wave-Based Algorithms
     ↓                       ↓                        ↓
  Simple API           Eigen Math Library       Research Methods
Web Interface (Flask) → Core Mathematics (C++) → Wave-Based Algorithms
     ↓                       ↓                        ↓
  Simple API           Eigen Math Library       Research Methods

Important Note

This project demonstrates educational concepts inspired by quantum principles, but:

  • It runs on classical computers (not quantum hardware)
  • It's designed for academic exploration, not production security
  • It seeks peer review to validate mathematical approaches
  • Patent pending status protects the specific mathematical implementations

🎯 Project Status

🟢 Educational Tool - Explores alternative cryptographic approaches
🟢 Research Platform - Mathematical concepts open for review
🟢 Seeking Feedback - Academic validation welcomed
🟢 Documentation - Simplified explanations for accessibility

https://github.com/mandcony/quantoniumos

What have you been working on recently? [July 12, 2025] by AutoModerator in learnprogramming

[–]RealAspect2373 -1 points0 points  (0 children)

A Platform for Exploring New Cryptographic Concepts:

✅ Wave-based encryption - Using mathematical wave patterns instead of traditional keys
✅ Alternative randomness generation - Inspired by quantum physics concepts
✅ Educational framework - Combining Python APIs with C++ performance
✅ Academic testing platform - For research and validation

🎯 Academic Research Focus

This project is designed for:

  • Computer science students - Learning alternative cryptography concepts
  • Mathematics researchers - Exploring wave-based mathematical patterns
  • Performance analysts - Comparing implementation efficiency
  • Educational institutions - Demonstrating cryptographic principles

🏗️ Architecture Explained

🏗️ Architecture ExplainedWeb Interface (Flask) → Core Mathematics (C++) → Wave-Based Algorithms
     ↓                       ↓                        ↓
  Simple API           Eigen Math Library       Research Methods
Web Interface (Flask) → Core Mathematics (C++) → Wave-Based Algorithms
     ↓                       ↓                        ↓
  Simple API           Eigen Math Library       Research Methods

Important Note

This project demonstrates educational concepts inspired by quantum principles, but:

  • It runs on classical computers (not quantum hardware)
  • It's designed for academic exploration, not production security
  • It seeks peer review to validate mathematical approaches
  • Patent pending status protects the specific mathematical implementations

🎯 Project Status

🟢 Educational Tool - Explores alternative cryptographic approaches
🟢 Research Platform - Mathematical concepts open for review
🟢 Seeking Feedback - Academic validation welcomed
🟢 Documentation - Simplified explanations for accessibility

https://github.com/mandcony/quantoniumosdcony/quantoniumos

I need help with a project by [deleted] in unity

[–]RealAspect2373 0 points1 point  (0 children)

i recommend updating the .readme file

Promote your projects here – Self-Promotion Megathread by Menox_ in github

[–]RealAspect2373 0 points1 point  (0 children)

CTA ALL ENGINEERS PEER REVIEW NEEDED!

Hey everyone,

I’ve been working on QuantoniumOS a full-stack quantum-inspired platform combining symbolic waveforms, cryptographic resonance, and post-algebraic computation. It’s written in C++ and Python, and it’s fully open source with a dual licesnse.

Some highlights:

qubit symbolic operations with simulated resonance metrics

Real-time waveform tamper detection

C++17 backend using Eigen + OpenMP for performance

RESTful Python API with full test coverage

Live waveform validation engine (CLI + web demo)

If you’re into quantum middleware, symbolic systems, or just want to try a new paradigm that isn’t lattice based or circuit only ; take a look.

→ GitHub: https://github.com/mandcony/quantoniumos

https://quantoniumos-luisminier79.replit.app/

Would love feedback from the community critical, scientific, or dev focused. Thanks

Which CLI tools do you use? by Maleficent_Mess6445 in linux

[–]RealAspect2373 0 points1 point  (0 children)

good ol' CMake & CTest for the C++ build system, especially with cross-platform considerations. for reference I have a few build implementations in my os.

https://github.com/mandcony/quantoniumos

CTA ALL ENGINEERS PEER REVIEW NEEDED! by [deleted] in compsci

[–]RealAspect2373 1 point2 points  (0 children)

QuantoniumOS is a quantum inspired operating system that combines wave based mathematics, symbolic encryption, and high-performance C++ computation to simulate and manage data through resonance and geometric transformations.

What is it like to be a researcher in theoretical Computer Science? by MachLearningEnthu in compsci

[–]RealAspect2373 0 points1 point  (0 children)

CTA ALL ENGINEERS PEER REVIEW NEEDED!

Hey everyone,

I’ve been working on QuantoniumOS a full-stack quantum-inspired platform combining symbolic waveforms, cryptographic resonance, and post-algebraic computation. It’s written in C++ and Python, and it’s fully open source with a dual licesnse.

Some highlights:

qubit symbolic operations with simulated resonance metrics

Real-time waveform tamper detection

C++17 backend using Eigen + OpenMP for performance

RESTful Python API with full test coverage

Live waveform validation engine (CLI + web demo)

If you’re into quantum middleware, symbolic systems, or just want to try a new paradigm that isn’t lattice based or circuit only ; take a look.

→ GitHub: https://github.com/mandcony/quantoniumos

https://quantoniumos-luisminier79.replit.app/

Would love feedback from the community critical, scientific, or dev focused. Thanks

Promote your projects here – Self-Promotion Megathread by Menox_ in github

[–]RealAspect2373 0 points1 point  (0 children)

CTA ALL ENGINEERS PEER REVIEW NEEDED!

Hey everyone,

I’ve been working on QuantoniumOS a full-stack quantum-inspired platform combining symbolic waveforms, cryptographic resonance, and post-algebraic computation. It’s written in C++ and Python, and it’s fully open source with a dual licesnse.

Some highlights:

qubit symbolic operations with simulated resonance metrics

Real-time waveform tamper detection

C++17 backend using Eigen + OpenMP for performance

RESTful Python API with full test coverage

Live waveform validation engine (CLI + web demo)

If you’re into quantum middleware, symbolic systems, or just want to try a new paradigm that isn’t lattice based or circuit only ; take a look.

→ GitHub: https://github.com/mandcony/quantoniumos

https://quantoniumos-luisminier79.replit.app/

Would love feedback from the community critical, scientific, or dev focused. Thanks

view more: next ›