As the title says, I'm looking for an investor or a firm to buy my projects. I have 3 distinct ready to deploy projects with a really good market value with me and I need to liquidate them due to some personal reasons. The person/the firm who aquires these, will have the source, project and implementation / deployment support from me until they get these assets deployed.

I have whitepapers, formal proof (TLA+/CBMC) for these projects as well.

As the title says, I'm looking for an investor or a firm to buy my projects. I have 3 distinct ready to deploy projects with a really good market value with me and I need to liquidate them due to some personal reasons. The person/the firm who aquires these, will have the source, project and implementation / deployment support from me until they get these assets deployed.

I have whitepapers, formal proof (TLA+/CBMC) for these projects as well.

As the title says, I'm looking for an investor or a firm to buy my projects. I have 3 distinct ready to deploy projects with a really good market value with me and I need to liquidate them due to some personal reasons. The person/the firm who aquires these, will have the source, project and implementation / deployment support from me until they get these assets deployed.

Added details of my projects,

ViralStack - For any scale of a business, you can paste a product description, or a url from any website and it generates you a 30 day viable market plan including image prompts to generate images for the whole market plan. You can use any image generator to do so and ViralStack includes a sample preview of the image (which will be generated by the image generating AI model you use) for the whole marketing plan. It gives you captions, video script and all. And it's polished to the top and have a demo ready

SIRS Engine (Enterprise) - an air gapped, CPU optimized (GPU supported) semantic retrieval engine that safely delivers mathematically regorous, state of the art AI embeddings on standard enterprise hardware. Available as a plug and play docker container. With api endpoints. 95%± semantic recall guaranteed, 75% vector compression 1024 dimentional embeddings to 256 active dimentions (uses my proprietory mathematical algorithm), 0% data leaks. Best for any conoany who wants to reduce their cloud bills.

CertAlloc (enterprise) - a high peperformance O(1) constant time pool memory allocator designed for safety critical embedded systems and any other similar use cases. Mathematically verified, formally verified with TLA+, CBMC proof. Have whitepapers as well

I'm working on a project called ShaderBridge. One of my personal projects. And ShaderBridge is a local-first, zero-dependency transpiler that translates GLSL/HLSL source code directly into WGSL for native WebGPU execution. Unlike cloud-based editors, it performs all compilation on the user’s local machine via Rust/WASM and runs strictly on the user's local GPU.

Still WIP and adding more shader, function support

https://reddit.com/link/1ujjcvw/video/re7hj69crdah1/player

And it works!

Anyone interested? 🙂 is this the right place to post this?

[supprimé]

Just a disclaimer right out of the gate: the actual execution code is closed-source. It’s the core engine for a B2B middleware startup my team at CyBurn Digital is building, so we have to keep that under wraps. However, I really wanted to share the mathematical architecture behind how we pulled this off. I'm looking for some brutal technical feedback on the theory, and I want people to absolutely stress-test the live sandbox.

The Bottleneck

While scaling our RAG pipelines, we realized we were burning serious cloud credits just hosting standard 1024D embeddings. Native database quantization—like Pinecone's SQ—helps a bit, but it only reduces precision. It doesn't touch the actual dimension count. We needed to physically cut the dimensions in half without tanking our semantic retrieval accuracy.

Matryoshka Representation Learning (MRL) handles this natively, but there's a catch: the model has to be trained that way from day one. We were sitting on millions of legacy vectors generated by standard models like BGE-M3, and re-embedding everything was financially out of the question. Standard PCA or SVD didn't work either. Truncating the matrix just drops the long tail of the variance, which dragged our retrieval fidelity down to a dismal ~82%.

The Math (Stepwise Iterative Residual Shrinkage)

Instead of just slashing dimensions and hoping for the best, we built a post-hoc linear algebra pipeline that isolates and recovers the lost data.

Think of it this way. Given an embedding matrix X, standard SVD factors it into U Σ V^T. When you truncate that down to k dimensions, you lose the residual information.

Our SIRS approach tackles it like this:

• Baseline Truncation: We compute the standard rank-reduced projection.
• Residual Isolation: We isolate the error matrix—literally the data that PCA usually throws in the trash:

E = X - X^truncated

• Iterative Patching: We run a localized shrinkage algorithm over E to pull out the highest-entropy semantic features that got left behind.
• Re-fusion: We fuse these "correction patches" right back into the truncated vector space.

The Result

You get the exact storage footprint of k dimensions, which cuts file sizes by 49%. Yet, it somehow retains the semantic capture of k + Δ dimensions. Testing this against our benchmarks using BAAI/bge-m3, we are maintaining a 93%+ semantic parity with the original, uncompressed vectors. Even better, you can still stack native database scalar quantization right on top of this for a massive, multiplicative reduction in size.

running locally on ryzen 3600 cpu

Stress-Test the Sandbox

Because the backend code is locked down, I deployed the compiled .so binary to a Streamlit sandbox on Hugging Face so you can break the logic yourself.

Drop in your own text chunks, run the compression matrix, and see exactly where the cosine similarity holds up or snaps.

Link to the Sandbox: https://huggingface.co/spaces/lucifahsl/cyburn-sirs-demo

I genuinely want your thoughts on this mathematical approach. Where does this break when you scale it to a production environment with 50M+ vectors? Does the compute overhead of calculating those residuals eventually outweigh the storage savings? Let me know.

Just a disclaimer right out of the gate: the actual execution code is closed-source. It’s the core engine for a B2B middleware startup my team at CyBurn Digital is building, so we have to keep that under wraps. However, I really wanted to share the mathematical architecture behind how we pulled this off. I'm looking for some brutal technical feedback on the theory, and I want people to absolutely stress-test the live sandbox.

The Bottleneck

While scaling our RAG pipelines, we realized we were burning serious cloud credits just hosting standard 1024D embeddings. Native database quantization—like Pinecone's SQ—helps a bit, but it only reduces precision. It doesn't touch the actual dimension count. We needed to physically cut the dimensions in half without tanking our semantic retrieval accuracy.

Matryoshka Representation Learning (MRL) handles this natively, but there's a catch: the model has to be trained that way from day one. We were sitting on millions of legacy vectors generated by standard models like BGE-M3, and re-embedding everything was financially out of the question. Standard PCA or SVD didn't work either. Truncating the matrix just drops the long tail of the variance, which dragged our retrieval fidelity down to a dismal ~82%.

The Math (Stepwise Iterative Residual Shrinkage)

Instead of just slashing dimensions and hoping for the best, we built a post-hoc linear algebra pipeline that isolates and recovers the lost data.

Think of it this way. Given an embedding matrix X, standard SVD factors it into U Σ V^T. When you truncate that down to k dimensions, you lose the residual information.

Our SIRS approach tackles it like this:

• Baseline Truncation: We compute the standard rank-reduced projection.
• Residual Isolation: We isolate the error matrix—literally the data that PCA usually throws in the trash:

E = X - X^truncated

• Iterative Patching: We run a localized shrinkage algorithm over E to pull out the highest-entropy semantic features that got left behind.
• Re-fusion: We fuse these "correction patches" right back into the truncated vector space.

The Result

You get the exact storage footprint of k dimensions, which cuts file sizes by 49%. Yet, it somehow retains the semantic capture of k + Δ dimensions. Testing this against our benchmarks using BAAI/bge-m3, we are maintaining a 93%+ semantic parity with the original, uncompressed vectors. Even better, you can still stack native database scalar quantization right on top of this for a massive, multiplicative reduction in size.

running locally on ryzen 3600 cpu

Stress-Test the Sandbox

Because the backend code is locked down, I deployed the compiled .so binary to a Streamlit sandbox on Hugging Face so you can break the logic yourself.

Drop in your own text chunks, run the compression matrix, and see exactly where the cosine similarity holds up or snaps.

Link to the Sandbox: https://huggingface.co/spaces/lucifahsl/cyburn-sirs-demo

I genuinely want your thoughts on this mathematical approach. Where does this break when you scale it to a production environment with 50M+ vectors? Does the compute overhead of calculating those residuals eventually outweigh the storage savings? Let me know.

Just a disclaimer right out of the gate: the actual execution code is closed-source. It’s the core engine for a B2B middleware startup my team at CyBurn Digital is building, so we have to keep that under wraps. However, I really wanted to share the mathematical architecture behind how we pulled this off. I'm looking for some brutal technical feedback on the theory, and I want people to absolutely stress-test the live sandbox.

The Bottleneck

While scaling our RAG pipelines, we realized we were burning serious cloud credits just hosting standard 1024D embeddings. Native database quantization—like Pinecone's SQ—helps a bit, but it only reduces precision. It doesn't touch the actual dimension count. We needed to physically cut the dimensions in half without tanking our semantic retrieval accuracy.

Matryoshka Representation Learning (MRL) handles this natively, but there's a catch: the model has to be trained that way from day one. We were sitting on millions of legacy vectors generated by standard models like BGE-M3, and re-embedding everything was financially out of the question. Standard PCA or SVD didn't work either. Truncating the matrix just drops the long tail of the variance, which dragged our retrieval fidelity down to a dismal ~82%.

The Math (Stepwise Iterative Residual Shrinkage)

Instead of just slashing dimensions and hoping for the best, we built a post-hoc linear algebra pipeline that isolates and recovers the lost data.

Think of it this way. Given an embedding matrix X, standard SVD factors it into U Σ V^T. When you truncate that down to k dimensions, you lose the residual information.

Our SIRS approach tackles it like this:

• Baseline Truncation: We compute the standard rank-reduced projection.
• Residual Isolation: We isolate the error matrix—literally the data that PCA usually throws in the trash:

E = X - X^truncated

• Iterative Patching: We run a localized shrinkage algorithm over E to pull out the highest-entropy semantic features that got left behind.
• Re-fusion: We fuse these "correction patches" right back into the truncated vector space.

The Result

You get the exact storage footprint of k dimensions, which cuts file sizes by 49%. Yet, it somehow retains the semantic capture of k + Δ dimensions. Testing this against our benchmarks using BAAI/bge-m3, we are maintaining a 93%+ semantic parity with the original, uncompressed vectors. Even better, you can still stack native database scalar quantization right on top of this for a massive, multiplicative reduction in size.

Running Locally on Ryzen 3600

Stress-Test the Sandbox

Because the backend code is locked down, I deployed the compiled .so binary to a Streamlit sandbox on Hugging Face so you can break the logic yourself.

Drop in your own text chunks, run the compression matrix, and see exactly where the cosine similarity holds up or snaps.

Link to the Sandbox: https://huggingface.co/spaces/lucifahsl/cyburn-sirs-demo

I genuinely want your thoughts on this mathematical approach. Where does this break when you scale it to a production environment with 50M+ vectors? Does the compute overhead of calculating those residuals eventually outweigh the storage savings? Let me know.

Just a disclaimer right out of the gate: the actual execution code is closed-source. It’s the core engine for a B2B middleware startup my team at CyBurn Digital is building, so we have to keep that under wraps. However, I really wanted to share the mathematical architecture behind how we pulled this off. I'm looking for some brutal technical feedback on the theory, and I want people to absolutely stress-test the live sandbox.

The Bottleneck

While scaling our RAG pipelines, we realized we were burning serious cloud credits just hosting standard 1024D embeddings. Native database quantization—like Pinecone's SQ—helps a bit, but it only reduces precision. It doesn't touch the actual dimension count. We needed to physically cut the dimensions in half without tanking our semantic retrieval accuracy.

Matryoshka Representation Learning (MRL) handles this natively, but there's a catch: the model has to be trained that way from day one. We were sitting on millions of legacy vectors generated by standard models like BGE-M3, and re-embedding everything was financially out of the question. Standard PCA or SVD didn't work either. Truncating the matrix just drops the long tail of the variance, which dragged our retrieval fidelity down to a dismal ~82%.

The Math (Stepwise Iterative Residual Shrinkage)

Instead of just slashing dimensions and hoping for the best, we built a post-hoc linear algebra pipeline that isolates and recovers the lost data.

Think of it this way. Given an embedding matrix X, standard SVD factors it into U Σ V^T. When you truncate that down to k dimensions, you lose the residual information.

Our SIRS approach tackles it like this:

• Baseline Truncation: We compute the standard rank-reduced projection.
• Residual Isolation: We isolate the error matrix—literally the data that PCA usually throws in the trash:

E = X - X^truncated

• Iterative Patching: We run a localized shrinkage algorithm over E to pull out the highest-entropy semantic features that got left behind.
• Re-fusion: We fuse these "correction patches" right back into the truncated vector space.

The Result

You get the exact storage footprint of k dimensions, which cuts file sizes by 49%. Yet, it somehow retains the semantic capture of k + Δ dimensions. Testing this against our benchmarks using BAAI/bge-m3, we are maintaining a 93%+ semantic parity with the original, uncompressed vectors. Even better, you can still stack native database scalar quantization right on top of this for a massive, multiplicative reduction in size.

Running Locally on Ryzen 3600

Stress-Test the Sandbox

Because the backend code is locked down, I deployed the compiled .so binary to a Streamlit sandbox on Hugging Face so you can break the logic yourself.

Drop in your own text chunks, run the compression matrix, and see exactly where the cosine similarity holds up or snaps.

Link to the Sandbox: https://huggingface.co/spaces/lucifahsl/cyburn-sirs-demo

I genuinely want your thoughts on this mathematical approach. Where does this break when you scale it to a production environment with 50M+ vectors? Does the compute overhead of calculating those residuals eventually outweigh the storage savings? Let me know.