# Short-Form Social

Targets: X, Mastodon, Threads, Bluesky, LinkedIn.

The job of these posts is not to explain the crate. The job is to earn one click from the right person and one reply that pulls the post into a Rust-developer audience that doesn't follow you yet. Everything below is written to do that — including the line breaks, which matter on every platform with truncation.

The X copy and tactics are grounded in the open-source Twitter/X algorithm (`twitter/the-algorithm` + `the-algorithm-ml`). The two findings that shape every recommendation:

- **Reply weight is 27× like weight.** A single reply moves the heavy ranker more than ~27 likes. A reply *the author engages back with* moves it ~150× more than a like. Source: `home-mixer/.../recap/README.md`. Engineer the parent post for replies, not likes.
- **Out-of-network distribution is gated by SimClusters.** A tweet's embedding is computed from the cluster fingerprint of the people who *like it first*. Five early likes from accounts in the Rust developer cluster route the post to every consumer with a Rust-cluster `InterestedIn` vector. A hundred likes from random followers do not. Source: `src/scala/com/twitter/simclusters_v2/README.md`.

---

## X — Launch Thread

### Parent post

Attach the platform-matrix card from `assets/distribution/platform-matrix.png` (see [`visuals.md`](visuals.md)). No link in the parent — drop the GitHub URL in reply 1.

```text
Pure Rust cryptography across six architecture families.

Linux CI: 3,545 wins, 1.61× geomean.
Apple Silicon: 235 wins, 1.25× geomean.

I built it because crypto kept being where my Rust services stopped being portable.

What should I benchmark next?
```

Why each piece is there:

- **Number first.** Heavy Ranker has no "interestingness" feature; the click that produces dwell time has to come from the human. A specific number is the cheapest way to earn it.
- **No link in the parent.** Open-source code does not penalize `recap.tweetfeature.has_link`, but folklore + a/b results from independent devs say external links cost reach. Cheap insurance.
- **Image attached.** `has_image` and `has_native_image` are first-class features; image posts dwell longer, and dwell is a heavy-ranker label.
- **Closing question.** Reply weight is 27×. Asking what to benchmark next is concrete enough to get one-line answers (every reply increases ranking).

### Reply chain

Post these as self-replies within ~15 seconds of the parent so they're treated as a thread, not as separate top-level posts.

**Reply 1 — links**

```text
Repo: github.com/loadingalias/rscrypto
Crates: crates.io/crates/rscrypto

One crate. Leaf features when you need one primitive (`sha2`, `aes-gcm`, `ed25519`, anything) or `full` for the whole stack: hashes, MACs, KDFs, password hashing, signatures, KEX, AEADs.
```

**Reply 2 — platform reach**

```text
The benchmark matrix:

• Intel Sapphire Rapids / Ice Lake
• AMD Zen4 / Zen5
• AWS Graviton3 / Graviton4
• IBM Z (s390x)
• IBM POWER10 (ppc64le)
• RISE RISC-V
• Apple Silicon MBP M1

IBM opened POWER10 + IBM Z runner access. RISE opened RISC-V.
```

**Reply 3 — trust model**

```text
How I keep myself honest:

• Portable Rust is the byte-for-byte authority
• Every SIMD/ASM kernel is differential-tested against it on every CI run — mismatch fails the build
• Constant-time MAC / AEAD / signature compares (no early exit)
• Zeroize-on-drop for every secret type
• Miri + continuous libFuzzer

Not FIPS validated. Not a TLS stack. Not a key store.
```

**Reply 4 — honest losses**

```text
It is not universally faster. PBKDF2-SHA256 setup, X25519 DH, RSA verification on Arm/RISC-V, and small-message AEAD rows are still pressure points.

The benchmark overview shows every tie and loss alongside every win. Hiding the losses would make the data useless:

github.com/loadingalias/rscrypto/blob/main/benchmark_results/OVERVIEW.md
```

**Reply 5 — review request**

```text
v0.3.0 is published. The most useful feedback right now:

• API mistakes that will block adoption
• unsafe / SIMD soundness
• benchmark methodology
• migration paths from RustCrypto, blake3, crc-fast

GitHub Issues for anything public. Private Vulnerability Reporting for anything sensitive.

Migration guides:
github.com/loadingalias/rscrypto/blob/main/docs/migration/README.md
```

### Quote-post fuel (post separately, on later days)

These are designed to be quotable on their own. Spread them over the launch week.

```text
The bet:

leaf feature when you need one primitive →
rscrypto = { version = "0.3.0", default-features = false, features = ["sha2"] }

full stack when you want the toolbox →
features = ["full"]

Either way: zero default deps, no C libs.
```

```text
RISC-V should not be a science project.
WASM should not be a second-class target.
no_std should not mean giving up the same primitives your server runs.

That is the standard I want rscrypto held to.
```

```text
The BLAKE3 result is deliberately narrow:

rscrypto is 2.31× geomean faster than the `blake3` crate for one-shot/keyed/derive-key inputs ≥64 KiB across Linux CI.

Apple Silicon MBP M1 is 1.80× in the same ≥64 KiB scope, with the 64 KiB rows called out as losses before larger inputs recover.

Tiny inputs and some platforms are closer. The overview spells out where.
```

```text
The trust model in one screen:

portable Rust is the byte-for-byte authority
↓
SIMD / ASM kernels are accelerators
↓
differential test on every CI run
↓
mismatch fails the build

I would rather have one slower but provable answer than ten fast ones I can't compare.
```

---

## Mastodon

Mastodon is federated and low-algorithmic. Hashtags are how content crosses instances. One post, rich content, no thread.

```text
I published rscrypto v0.3.0 — a pure-Rust cryptography stack with hardware acceleration across six architecture families.

Scope: SHA-2/3, BLAKE2/3, Ascon, XXH3/RapidHash, HMAC/HKDF/PBKDF2/KMAC, Argon2/scrypt with PHC strings, RSA/Ed25519/X25519, six AEADs, the full CRC family.

Benchmarked on nine Linux CI runners (Intel Sapphire Rapids/Ice Lake, AMD Zen4/Zen5, Graviton3/4, IBM Z, IBM POWER10, RISE RISC-V): 3,545 wins and 5,210 wins-or-ties out of 5,832 fastest-external Linux CI comparisons, 1.61× geomean vs the fastest matched Rust baselines.

Apple Silicon MBP M1 local full run: 235 wins and 450 wins-or-ties out of 463 fastest-external comparisons, 1.25× geomean.

Zero default dependencies. No C, no FFI, no OpenSSL. Portable Rust is the byte-for-byte authority; SIMD/ASM kernels are differential-tested against it on every CI run.

Not FIPS validated. Not a TLS stack. v0.3.0 — looking for hard review.

https://github.com/loadingalias/rscrypto
https://crates.io/crates/rscrypto

#Rust #RustLang #Cryptography #OpenSource #Performance #NoStd
```

---

## Bluesky

Bluesky's discovery is largely follow-graph + custom feeds. No algorithmic boost; one strong post + a link reply works.

```text
I published rscrypto v0.3.0.

Pure Rust cryptography across six architecture families. 3,545 wins and 5,210 wins-or-ties out of 5,832 fastest-external Linux CI comparisons, plus 235 wins and 450 wins-or-ties out of 463 Apple Silicon MBP M1 comparisons. Zero default deps. No C, no FFI.

I built it because crypto kept being the place my Rust services stopped being portable.
```

Reply with the link:

```text
Repo: https://github.com/loadingalias/rscrypto
Benchmarks: https://github.com/loadingalias/rscrypto/blob/main/benchmark_results/OVERVIEW.md

v0.3.0. Hard review wanted: API, unsafe/SIMD, benchmark methodology, migration paths.
Migration guides: https://github.com/loadingalias/rscrypto/blob/main/docs/migration/README.md
```

If you have a Rust-related custom feed (e.g., the Rust feed run by community curators), the post should match its hashtag conventions: include `#rust` and `#cryptography` to be picked up by feed builders that filter on tags.

---

## Threads

Same shape as the X thread; Threads is owned by Meta and the algorithm differs but the same principles apply (replies > likes, single post + chain works). Reuse the X parent verbatim. Threads truncates aggressively at the third line, so put the strongest line first.

---

## LinkedIn

Different audience: technical leaders, hiring managers, infra/security buyers. The hook is the supply-chain story, not the speedup. LinkedIn's algorithm rewards dwell time and "meaningful interactions" — long-form text without a link in the body, link in the first comment.

```text
I released rscrypto v0.3.0 today.

If you ship Rust services, you've probably noticed that crypto is the place your supply chain stops being clean. To get hardware acceleration you reach for crates that wrap C libraries; to keep things pure Rust you accept slower paths or per-primitive crate fragmentation. Both choices ripple into your build matrix, your audit surface, and the answers you give to security review.

I built rscrypto because I wanted a single answer.

It's a pure-Rust cryptography stack: hashes, MACs, KDFs, password hashing, RSA/Ed25519/X25519, six AEADs, the full CRC family. Zero default dependencies. No C, no FFI, no OpenSSL. One feature flag for one primitive (`sha2`, `rsa`, `aes-gcm`) or `full` for the whole toolbox.

The benchmark matrix runs on nine Linux CI environments — Intel Sapphire Rapids and Ice Lake, AMD Zen4 and Zen5, AWS Graviton3 and Graviton4, IBM Z, IBM POWER10, RISE RISC-V — plus a local Apple Silicon MBP M1 full run. On 5,832 fastest-external Linux CI comparisons, rscrypto wins 3,545, wins-or-ties 5,210, and has a 1.61× geometric-mean speedup against the fastest matched Rust baselines. On Apple Silicon, it wins 235 of 463, wins-or-ties 450 of 463, and has a 1.25× geomean. SHA-3 hits 2.15× on Linux CI and 0.94× on Apple Silicon. SHAKE hits 1.86× and 1.32×. CRCs hit 5.03× and 2.76×. BLAKE3 large inputs hit 2.31× and 1.80×. The overview shows every tie and loss next to every win.

The trust model: the portable Rust path is the byte-for-byte authority. SIMD and ASM kernels are accelerators, differential-tested against the portable path on every CI run. Constant-time MAC/AEAD/signature comparisons. Zeroize-on-drop for secret material. Continuous Miri and libFuzzer.

This is the 0.3 line. It is not FIPS validated, not a TLS stack, and not a request to blindly replace mature crypto in production. It is a request for hard public review before it becomes infrastructure.

If you maintain Rust services or care about supply-chain hygiene in regulated environments, I'd value a serious read.
```

First comment (the link, posted by you to start the thread):

```text
Repo: https://github.com/loadingalias/rscrypto
Crates.io: https://crates.io/crates/rscrypto
Benchmarks (every win, tie, loss): https://github.com/loadingalias/rscrypto/blob/main/benchmark_results/OVERVIEW.md
Migration guides: https://github.com/loadingalias/rscrypto/blob/main/docs/migration/README.md
```

---

## Posting Playbook

These are the operational tactics that move ranking on X. Most translate cleanly to Threads. Mastodon and Bluesky don't have algorithmic boost, so timing/replies matter only for human reach.

### When to post

- **Tuesday, Wednesday, or Thursday** between **14:00 and 17:00 US Eastern**. Captures US dev afternoon and EU evening commute. `user_request_context_aggregate.dow` and `.hour` are real heavy-ranker features; the model has learned hour-of-day baselines per viewer.
- Avoid Friday afternoon, weekends, US holidays, and the same week as a major Rust release (RustConf week, edition release week, etc.) — your post will compete with the cluster's other content for cluster-leader attention.

### First 30 minutes — the SimCluster race

The single highest-leverage thing you can do is land **3–5 likes from accounts that are clearly in the Rust developer SimCluster** within the first 30 minutes. Tweet embeddings are computed from the `InterestedIn` vectors of the accounts that like it; early likes from cluster anchors route the post into the cluster's `clusterId → TopTweet` index. After that, every consumer with a Rust-cluster `InterestedIn` vector becomes eligible.

Practically:

- DM 3–5 people you actually know in the Rust community 24 hours before launch with a heads-up. Ask them to like the post if they think it's worth seeing.
- Post into a Rust Discord / Matrix room with the link about an hour after the parent, after the SimCluster has stabilized.
- Do **not** mass-tag accounts in the parent post. `num_mentions` is a feature; high mention counts correlate with spam labels.

### First 60 minutes — the reply race

Reply weight is 27× like weight. **Reply to every single reply in the first hour**, even one-word ones. Each reply you author also fires the `recap.tweetfeature.is_reply_replied_by_author` signal, which drives one of the largest positive labels in the model.

If a reply is a real technical question, answer it in 1–2 lines and link to the relevant doc. If it's hostile, answer technically — never sarcastic, never hostile back. A blocked-by-author signal is `−74`; a report is `−369`. Hostility costs you reach across the cluster.

### Skeptics — answer, don't argue

Expected critiques and the one-line replies that defuse without arguing:

- **"Don't roll your own crypto."** → "Agreed. Portable Rust is the byte-for-byte authority; every SIMD/ASM kernel is differential-tested against it on every CI run. Official vectors, fuzz, Miri, and the public benchmark overview are all in the repo."
- **"Why not RustCrypto?"** → "Some pieces may eventually go upstream. The architectural reason this exists as one crate: one dispatch model, one error model, one feature matrix, one platform matrix, no mandatory external crates for `full`."
- **"BLAKE3 is already optimized."** → "Yes — the claim is narrow: large one-shot/keyed/derive-key inputs ≥64 KiB, 2.31× Linux CI and 1.80× Apple Silicon geomean. Tiny inputs and Apple Silicon 64 KiB rows are not wins. The overview spells it out."
- **"Zero deps?"** → "Zero default deps. `getrandom`, `serde`, and `rayon` are opt-in."

### What not to do

- Do not delete the parent and repost if it doesn't catch in the first hour. Edits / deletes don't penalize directly in the open code, but you forfeit any embedding the post built up.
- Do not post the same copy four times across four accounts. `AuthorDiversityFloor` (0.25) and `AuthorDiversityDecayFactor` (0.5) cap repeated authors.
- Do not boost the post with Premium reply prioritization unless you understand what you're trading. Free organic distribution from the SimCluster is more valuable than paid placement that signals "promoted" to skeptical Rust readers.
- Do not chase total followers. The metric that matters is whether the post landed in the right cluster.

---

## Visuals to Attach

See [`visuals.md`](visuals.md) for production specs and final filenames. The X parent should attach `assets/distribution/platform-matrix.png`. The benchmark chart `assets/distribution/linux-geomean-chart.svg` works in reply 4. LinkedIn does well with `assets/distribution/dependency-collapse.png`. Mastodon and Bluesky take the same image as X.

Do not attach:

- Padlock stock art.
- "Military-grade" / "bulletproof" / "unbreakable" imagery.
- AI-generated cyberpunk crypto art.
- The Rust gear logo unless you're following Mozilla's trademark guidance.
