# Launch Case Studies

This file is the research layer behind the platform copy. The point is not to
imitate unrelated projects. The point is to extract the launch mechanics that
worked with developers who care about low-level software, performance, supply
chains, security, agents, and portability.

## Audience Model

The `rscrypto` buyer is not one person.

| Segment | What they care about | What makes them skeptical |
|---|---|---|
| Rust library maintainers | Small dependency trees, stable APIs, docs.rs, MSRV, feature flags | New crypto, ecosystem fragmentation |
| Security engineers | Correctness, side channels, auditability, dependency provenance | Performance-first crypto claims |
| Embedded/no_std/WASM teams | Portable fallback, no C toolchain, no allocator assumptions | Hidden std/alloc or platform assumptions |
| Infra/storage/database teams | Checksums, hashing throughput, reproducible benches | Microbenchmarks that do not match workloads |
| Performance engineers | CPU-specific backends, benchmark methodology, losses shown | "Fastest" claims without hardware details |
| AI-agent/devtools users | Fewer moving parts, simple install, sharp before/after value | Hand-wavy platform claims |

The strongest shared pain:

> Crypto is often the place where otherwise portable Rust software stops being
> portable: native libraries, target gaps, dependency piles, feature drift, and
> per-primitive performance surprises.

The launch should make that pain visible, then show `rscrypto` as the practical
way out: leaf features when you need one primitive, `full` when you want the
stack, no C libs, zero default deps, broad hardware acceleration, and public
benchmark data.

## Core Case Studies

| Project | Why it matters | What worked | What to borrow | What not to borrow |
|---|---|---|---|---|
| OpenClaw | Massive GitHub breakout with broad dev attention and repeated HN front-page discussion. | Simple identity, huge promise, immediate install path, many integrations, visible community proof. | Big product sentence, platform breadth, docs by goal, star/social proof after the core pitch. | Do not use mascot energy or security hand-waving for crypto. OpenClaw also shows how fast trust backlash arrives. |
| MiroFish | GitHub Trending style breakout with heavy visual demo energy and an ambitious "predict anything" frame. | One-sentence world model, screenshots, demo videos, workflow diagram, live demo. | Visual proof sells breadth. For `rscrypto`, use platform/benchmark visuals instead of abstract imagery. | HN did not reward vague ambition; keep HN technical and falsifiable. |
| RTK | Rust devtool that turns one concrete pain into one concrete metric. | "60-90% savings", single Rust binary, zero-dependency framing, before/after table, quick install. | Lead with a measurable operational win: dependency collapse plus performance. Use before/after tables. | Avoid repeating huge percentage claims without methodology; crypto audiences will push back. |
| Lucebox / Megakernel | Systems-performance launch with a bold hardware claim and reproducible bench recipe. | Challenger framing: old hardware beats new hardware because software changed. Includes exact hardware, power, tokens/sec, install, and benchmark command. | It is acceptable to be bold if the benchmark recipe sits next to the claim. | Do not overfit to one benchmark; `rscrypto` should emphasize matrix breadth. |
| BLAKE3 | Canonical crypto-performance launch precedent. | Property bullets, chart early, explicit security caveat, test vectors, paper/spec links, adoption list. | For crypto, boast in properties, not vibes: faster, secure caveats, parallelizable, tested, specified. | Do not claim `rscrypto` is a cryptographic design like BLAKE3. It is an implementation stack. |
| RustCrypto crypto-bigint | Trust-first crypto library copy. | Constant-time defaults, `no_std`, audit note, explicit unsuitable processors, MSRV policy. | Put caveats and threat-model boundaries in the launch, especially for Rust forum/reddit. | Do not bury "not suitable" notes. They increase trust. |

## Platform Top Fives

These are not all "projects released on the platform"; some are posts or
threads that show what the platform rewards for this audience.

### Hacker News

HN rewards technical artifacts, proof, and controversy. It punishes vague
ambition and exaggerated security language.

1. OpenClaw discussions: huge comment volume came from ecosystem and trust
   consequences, not just the repo.
2. BLAKE3: clean technical property list, chart, spec/paper, explicit caveat.
3. Lucebox Megakernel: bold claim plus hardware table and reproduction path.
4. Browsernode/agent-browser style posts: concrete demo tasks and clear DX.
5. RTK: simple utility, measurable pain, clear install, but HN traction stayed
   small when the post sounded too promotional.

`rscrypto` HN posture:

- Lead with artifact: benchmarks across ten CPU environments.
- Put "not FIPS, not TLS, review wanted" in the first comment.
- Use one metric block, then the methodology link.
- Do not include images in the top-level HN submission.
- Use "pure Rust" only when paired with "SIMD/ASM where appropriate"; HN
  crypto readers know constant-time code is not just high-level Rust.

### Reddit

Reddit rewards practical value, identity, and visible effort. r/rust specifically
requires Rust relevance and dislikes broad self-promotion.

1. RustCrypto release posts: clear crate list, pure Rust/no_std framing, breaking
   changes called out.
2. BLAKE3 posts: speed claim plus relevance to Rust official implementation.
3. RTK token-savings posts: personal pain, numeric before/after, immediate use.
4. Lucebox/LocalLLM posts: hardware-specific proof and practical commands.
5. Pure-Rust vs C-wrapper discussions: users care about cross-compilation,
   dependency hell, toolchains, and understandable source.

`rscrypto` Reddit posture:

- The headline should be useful, not grandiose.
- In r/rust, emphasize Rust-native portability, feature flags, docs, and review.
- In r/embedded or WASM-adjacent communities, post only a tailored version about
  no_std/WASM/constrained targets.
- In security/crypto communities, ask for review first and performance second.
- Use one chart or screenshot, not a logo.

### Rust Users Forum

The forum rewards careful engineering notes, MSRV, feature flags, and explicit
limitations. It is the least tolerant of hype and the best place to invite API
review.

1. `crypto-bigint`: trust copy, audit context, constant-time boundaries.
2. Pure-Rust `sha2`: "no C code, builds everywhere Rust does" is still the
   clearest portability argument.
3. RustCrypto release announcements: crate ecosystem stewardship, migration
   awareness, breaking changes.
4. `cbor-core`: deterministic behavior, vectors, rejection rules.
5. GPU/runtime posts such as KAIO/Burn-style announcements: benchmark claims
   need exact context and caveats.

`rscrypto` Rust Forum posture:

- Say "published" not "launched".
- Include MSRV and edition.
- Explain why this is not just fragmentation.
- Ask for feature/API/unsafe review.
- Keep visuals optional and subdued.

### X / Mastodon / Threads

Short-form social rewards compact contrast. It also rewards visuals more than
text. The key is to create a sentence people can quote without needing the
whole README.

1. OpenClaw: identity plus "any OS / any platform" made the project easy to
   describe.
2. MiroFish: "predict anything" was a strong curiosity hook, helped by images.
3. RTK: one numeric outcome, one command-line mental model.
4. Lucebox: "the hardware was not the limit, the software was" style framing.
5. BLAKE3: property bullets and chart made the technical pitch portable.

`rscrypto` social posture:

- Use the line: "Crypto should not be the place your Rust app stops being
  portable."
- Attach the platform matrix card or benchmark bar chart.
- Make one claim per post.
- Use caveats as credibility: "not FIPS, not TLS, v0.3 review wanted."
- Do not say "canonical" in the first public post. Say "the bet".

### DEV / Long-Form

Long-form rewards narrative and diagrams. The article should not just be a
release note; it should explain the constraint and why the architecture exists.

1. Lucebox: starts with a contrarian systems observation and backs it with
   hardware tables.
2. BLAKE3: property list, chart, paper/spec/test-vector depth.
3. RTK: before/after economics table and "how it works" diagram.
4. MiroFish: screenshots, workflow, video, live demo.
5. RustCrypto crypto-bigint: security notes and unsupported cases.

`rscrypto` long-form posture:

- Start with the portability bottleneck.
- Show "leaf feature" and "`full`" as two usage modes.
- Include four visuals: dependency collapse, platform matrix, benchmark bar
  chart, and "fallback -> dispatch -> backend" architecture.
- End with review requests and migration paths, not applause.

## What To Change In Our Copy

### Increase The Central Claim

Current copy says "single-crate crypto stack." That is true but too flat.

Better public frame:

> `rscrypto` is a bet that crypto should stop being the portability bottleneck
> in Rust: one feature-selectable crate, no C libs, zero default deps, portable
> fallbacks, and hardware acceleration across the CPU families modern software
> actually runs on.

Use that sentence in DEV, LinkedIn, and social. Use a drier version on HN and
Rust forum.

### Use Before/After Tables

RTK and BLAKE3 show that developers respond to immediate comparison.

Add a "before / after" block everywhere practical:

| Before | After |
|---|---|
| Many crypto/hash/checksum crates | One feature-selected crate |
| OpenSSL/C FFI risk for some stacks | No C libraries in the primitive stack |
| Per-crate platform assumptions | One platform matrix |
| Per-primitive dispatch behavior | One dispatch model |
| x86/ARM focus | x86_64, ARM64, RISC-V, IBM Z, POWER10, Apple Silicon |

### Make Portability Emotional But Falsifiable

Good:

> RISC-V should not be a science project. WASM should not be a second-class
> target. Embedded should not mean giving up the same primitive stack your server
> uses.

Risky:

> Works everywhere.

### Boast Where We Have Proof

Allowed:

- "zero default dependencies"
- "no C libs in the primitive stack"
- "benchmarked across ten environments"
- "1.61x Linux geomean across 5,832 fastest-external comparisons"
- "1.25x Apple Silicon MBP M1 geomean across 463 fastest-external comparisons"
- "2.31x geomean faster than `blake3` for large one-shot/keyed/derive-key
  inputs in the Linux matrix; 1.80x on Apple Silicon, with 64 KiB losses named"
- "RISC-V, IBM Z, POWER10, and Apple Silicon are in the coverage story, not
  afterthoughts"

Avoid:

- "secure by default"
- "drop-in RustCrypto replacement"
- "canonical"
- "fastest crypto library"
- "production audited"

## Source Links

- OpenClaw repository: https://github.com/openclaw/openclaw
- OpenClaw HN search: https://hn.algolia.com/api/v1/search?query=OpenClaw&tags=story
- MiroFish repository: https://github.com/666ghj/MiroFish
- MiroFish HN search: https://hn.algolia.com/api/v1/search?query=MiroFish&tags=story
- RTK repository: https://github.com/rtk-ai/rtk
- RTK HN search: https://hn.algolia.com/api/v1/search?query=rtk%20token%20cli&tags=story
- Lucebox / Megakernel repository: https://github.com/Luce-Org/luce-megakernel
- Lucebox coverage: https://awesomeagents.ai/news/rtx-3090-beats-m5-max-megakernel-deltanet/
- BLAKE3 repository: https://github.com/BLAKE3-team/BLAKE3
- BLAKE3 HN discussion: https://news.ycombinator.com/item?id=22021769
- RustCrypto crypto-bigint repository: https://github.com/RustCrypto/crypto-bigint
- crypto-bigint forum post: https://users.rust-lang.org/t/ann-crypto-bigint-v0-6-0-a-big-integer-library-designed-with-constant-time-algorithms-for-cryptography/124472
- Pure-Rust sha2 forum post: https://users.rust-lang.org/t/announcing-the-pure-rust-sha2-crate/5723
- RustCrypto release announcements: https://users.rust-lang.org/t/rustcrypto-release-announcements/59149
- r/rust RustCrypto release: https://www.reddit.com/r/rust/comments/h0em5n
- r/rust pure-Rust library discussion: https://www.reddit.com/r/rust/comments/19faoyg
