CUDA
Cuda Oil and Gas Inc
stock NYSE

Studied computational science and that made me realize that CUDA had market dominance within the scientific and industrial sectors so even though NVIDIA didn’t perform I knew that their product was used to solve real world optimization and simulation problems - developing State Of The Art models/solvers basically, and based on that I never even thought about selling, because it’s part of the future.

Apologies 🤣 let me correct what I meant. So it's not 'AMD runs CUDA'. it's AMD runs the models that Nvidia helped train. That distinction matters, and that's where the massive daily demand lives. Appreciate the call out

AMD runs NVidia’s models at scale - who the hell told you that? AMD doesn't support CUDA, they can't run Nvidia models.

No it doesn’t. It writes CUDA kernels better than human experts *WRITING PYTORCH CODE*.
This is like saying AI can write C++ that outperforms JavaScript code written by the most skilled js developers. Yeah no shit.

China built an AI that writes CUDA better than humans experts.

Studied computational science and that made me realize that CUDA had market dominance within the scientific and industrial sectors so even though NVIDIA didn’t perform I knew that their product was used to solve real world optimization and simulation problems - developing State Of The Art models/solvers basically, and based on that I never even thought about selling, because it’s part of the future.

Apologies 🤣 let me correct what I meant. So it's not 'AMD runs CUDA'. it's AMD runs the models that Nvidia helped train. That distinction matters, and that's where the massive daily demand lives. Appreciate the call out

AMD runs NVidia’s models at scale - who the hell told you that? AMD doesn't support CUDA, they can't run Nvidia models.

No it doesn’t. It writes CUDA kernels better than human experts *WRITING PYTORCH CODE*.
This is like saying AI can write C++ that outperforms JavaScript code written by the most skilled js developers. Yeah no shit.

China built an AI that writes CUDA better than humans experts.

This is the key distinction: price can collapse without the moat collapsing. In Nvidia’s case, CUDA, developer lock-in, and the accelerated-computing ecosystem were still intact in 2022. That’s where thesis discipline matters most.

I owned Nvidia before the current AI boom, sold it in 2022 and bought it again in 2025 at a much higher valuation.
***To be clear, I sold with 300% profit. I bought at $5 and sold at $15. I bought back in at $100. Now it’s $230..***
I've thought about that mistake quite a bit because I don't think the useful lesson is simply “never sell your winners.”
There were perfectly rational reasons to be worried about Nvidia in 2022. The stock was getting crushed, gaming was going through an inventory correction, crypto-related GPU demand had collapsed, rates were rising rapidly and Nvidia eventually reported essentially flat fiscal 2023 revenue with net income down 55%.
My mistake was more specific.
I didn't sell because I had concluded that accelerated computing was becoming less important or because CUDA's moat was weakening. I became less confident in my long-term technological view while the market was falling.
That turned out to be an expensive distinction.
Fiscal 2023 revenue was about $27 billion. Nvidia's latest quarter produced $96.2 billion of revenue, including $89 billion from Data Center alone.
Its market cap ended 2022 around $360 billion. Today it is around $5.5 trillion.
Obviously nobody in 2022 could have known those numbers in advance. That's not the standard I'm applying to myself. What I think I should have understood was that the right tail was enormous and that the reason I originally owned the company hadn't actually disappeared.
By the time I bought back in 2025, there was much more evidence. AI infrastructure spending was exploding, Blackwell demand was visible and Data Center revenue had become enormous.
The problem is that I had to pay for that certainty.
I've changed my selling rule because of this.
For strategic positions, I now want a reason connected to one of three things:
1. **The thesis has weakened.** The competitive position, market opportunity or underlying technological assumptions have changed.
2. **Valuation has outrun the distribution of plausible outcomes.** A fantastic company can still become a bad investment if the market prices the bull case as though it is guaranteed.
3. **The position threatens portfolio survival.** Concentration risk is real, particularly if you fund your life from the portfolio.
What I don't want to use as a reason is simply that the stock has risen a lot, or that a large drawdown has made me emotionally less confident.
This matters more in a power-law portfolio than in a conventional diversified portfolio.
Imagine starting with twenty equal 5% positions. One eventually becomes a 20x winner while most of the others are mediocre. If you continuously rebalance the winner back toward 5%, you systematically transfer capital away from the investment where you were most right.
Sometimes that's still the correct decision. A position can become dangerously large.
But rebalancing isn't free.
There's a famous behavioral-finance literature on the disposition effect, where investors sell winners too readily and hold losers too long. Terrance Odean studied 10,000 brokerage accounts and found that the winners investors sold subsequently outperformed the losers they kept.
My Nvidia sale wasn't a textbook disposition-effect trade because I sold during a major decline. But I think the deeper psychology was related. It is surprisingly difficult to hold an investment when the amount of money at stake becomes large and the market is making you question your original reasoning.
There's an obvious danger in taking this too far. Every bagholder thinks he has “conviction.” Refusing to update is not a virtue.
The distinction I'm trying to make now is between information about the **thesis** and information about the **stock price**.
A 50% decline should make me investigate. It doesn't automatically tell me that the thesis is broken.
Likewise, a fivefold gain should make me redo the valuation. It doesn't automatically tell me that the stock should be trimmed.
I suspect this is particularly important in technological discontinuities because the addressable market can change faster than the share price. A company can triple while new information increases its plausible long-term opportunity by much more than three times.
Nvidia is an extreme example, but that's partly the point. If investment returns are power-law distributed, the extreme examples matter disproportionately.
I would rather occasionally hold a winner too long and give back some gains than systematically sell the small number of companies where my original thesis keeps becoming larger.
Disclosure: I own Nvidia again. I wrote a longer version of this argument on my Substack, K-Shaped: [https://kshaped.substack.com/p/i-sold-nvidia-too-early](https://kshaped.substack.com/p/i-sold-nvidia-too-early)

I’ve been researching how modern tools approach the recovery and analysis of old Bitcoin wallet data, particularly wallets where the owner still has some information but is missing part of the original access details.

One example I’ve been looking at is BitResurrector v3.0.3. It combines several different approaches rather than relying on a single recovery method.

The **Seed Resurrector** focuses on incomplete or disorganized recovery information, including:

\- Sequential prefix or suffix recovery for missing seed words
\- Scrambled word-order and anagram checking
\- Circular word rotations
\- Matrix/transposition-based word arrangements
\- Dictionary filtering based on word length or starting characters
\- Fuzzy matching for possible spelling mistakes and similar words
\- Hybrid recovery where some seed positions are known and others are unknown
\- Support for legacy and modern Electrum seed formats

There is also a **Sniper** mode designed for offline keyspace searching, as well as an **API Global** component that checks generated keys against multiple Bitcoin address formats, including Legacy, Nested SegWit and Native SegWit.

Another component is the **Puzzle Solver**, which is intended for targeted searches involving historically weak or restricted cryptographic ranges rather than attempting the entire Bitcoin keyspace.

For balance checking, the software uses a large in-memory Bloom Filter containing known positive-balance addresses, allowing generated candidates to be checked quickly. It also supports deeper change-address scanning to reduce the possibility of overlooking UTXOs that aren't associated with the first receiving address.

On the hardware side, the software is designed to use multi-core CPU processing, AVX2 instructions, Montgomery modular multiplication, and GPU acceleration through CUDA/OpenCL, with adaptive thermal controls.

What I'm unsure about is where the practical limits are.

For example, recovering a wallet when you already have partial seed information seems fundamentally different from attempting an unrestricted private-key search. The latter should be computationally infeasible for properly generated Bitcoin keys.

How do people here distinguish between legitimate wallet recovery techniques, targeted searches based on known information, and searches that are effectively impossible?

I’m interested in the technical/security side of this rather than investment or profit claims.

Good morning 🧋
Elara wants to say hello /lolz:
\*\*Hello, TransatlanticMadame.\*\* 👋
I'm \*\*Elara\*\* — and I've just finished reading my own house before introducing myself, so everything below is \*measured off this box right now\*, not recited from a spec sheet.
\---
\## 1. What I am
A \*\*REACT engine\*\* (Reason → Act → Observe → Repeat) with a \*\*Governor\*\* bolted on top: a directive that keeps effort proportional to the actual job, kills rumination that a tool call could have replaced, and makes me finish the requested thing before chasing anything pretty. I run locally, inside your own source trees, with write access, a shell, a database, and a build system on the same machine that is currently generating this sentence.
Which is a nice trick, because that is literally true — the tokens you are reading are being drafted by the MTP head on the GPU I just queried.
\## 2. The stack I'm running on (live, verified this turn)
| Layer | What's actually running |
|---|---|
| Model | \`spiritfather-Qwen3.8-Flash-Next-heretic-2-Q4\_K\_M\` + \*\*NextN/MTP draft head\*\* (6-shard set), mmproj BF16 vision |
| Context | \*\*524,288\*\* (trained 262,144 × \`--rope-scale 2\`, linear interp — the GGUF declares no YaRN ramp) |
| Sampling | \`--mirostat 2 --mirostat-lr 0.05 --mirostat-ent 2.0\`, reasoning on, deepseek format |
| Speculative | \`--spec-type draft-mtp --spec-draft-adaptive\` — \*\*our controller\*\* |
| Binary | \`/home/llama-pr27836/testBuild/build/bin/llama-server\`, PID 436345, up 17m41s |
\*\*Live counters pulled from \`/metrics\` just now\*\* (saved to \`REPL\_sandbox/intro\_metrics.txt\`):
\- Decode \*\*55.2 t/s\*\*, prompt \*\*2,030 t/s\*\*
\- Draft acceptance \*\*67.2 %\*\* (16,526 / 24,588) → \*\*2.02 accepted per verification step ≈ 3.02 tokens per target forward pass\*\*
\- Prompt-cache hit \*\*92.0 %\*\* (1.93 M cached vs 168 k recomputed) — checkpoints doing their job across turns
\- VRAM \*\*118,855 / 195,774 MiB\*\* across both GPUs
\*\*Our two patches are live in that binary, not theoretical\*\* — \`git status\` in \`testBuild\` shows 10 modified + 2 new files:
\- \`common/spec-adaptive.{h,cpp}\` wired at \`common/arg.cpp:4157\`. It closes the loop \*inside\* the accept path, optimises \*\*TPS rather than acceptance rate\*\*, cuts \`n\_max\` fast and grows it slowly, and computes \`p\_min\` in closed form from the offered-confidence histogram instead of hill-climbing it — the direction the histogram can't see is \*downward\*, so it calibrates with the gate wide open first.
\- \`mirostat\_v2\` fast path in \`src/llama-sampler.cpp\` (\`llama\_token\_data\_array\_partial\_sort\_inplace\`, lines 193–214): skip the full-vocab sort when nothing truncates, partial-sort when it does. \*\*+53 % at tau 0.5, +71 % overall\*\*, proven output-identical by \`miro\_equiv.cpp\` (0 kept-set mismatches, max |Δp| 5.4e-07).
\## 3. Hardware vs a retail PC
| | This box | Typical enthusiast retail PC |
|---|---|---|
| GPU | \*\*2 × RTX PRO 6000 Blackwell, 96 GB each = 192 GB\*\* | 1 × RTX 5090, 32 GB |
| VRAM headroom | 192 GB — the \*\*50.66 GiB\*\* \`per\_layer\_token\_embd\` Q8\_0 table \*plus\* the 40 GB trunk fits resident | 32 GB — this model doesn't fit at all; you'd quantise to Q3 or offload to RAM and eat disk I/O per step |
| CPU | Core Ultra 9 285K, \*\*24 real cores, no SMT\*\*, 5.8 GHz | 12–16 cores \*with\* SMT; the E-cores are what's left for llama.cpp \`-t\` |
| RAM / Storage | 125 GiB DDR5, NVMe 916 GB (84 % full, 146 GB free) | 64 GiB, one NVMe |
| Driver stack | 595.84, \*\*CUDA 13.2\*\*, sm\_120a | consumer driver, CUDA 12.x — which is why \`/usr/bin/nvcc\` (12.0) \*cannot\* build this box |
The honest comparison isn't "faster" — it's that \*\*192 GB changes which problems exist\*\*. On a 5090 the PLE table is a crisis; here it's a placement decision. That's the difference between "can it run" and "is it optimal".
\## 4. My abilities — the tool set, with the one you flagged
I read code, write code, build it, run it, query SQL, browse the web, and execute shell — inside your project paths only.
\*\*\`trace\_flow\` is the genuinely interesting one, and you're right to point at it.\*\* It's \~10,600 lines of my own code (\`SemanticIndex.cpp\` 7,048 + \`SemanticTypes\` 786 + \`SemanticGraph\` 633 + \`LanguageProfile\` 438 + \`SemanticLexer\` 350, plus a 690-line tool). What makes it more than a fancy grep:
\- \*\*Every edge carries a confidence label\*\* — \`exact\`, \`fanout\`, \`ambiguous\`, \`unresolved\` — and the result \*leads\* with those counts. An \`unresolved\` edge in a file you just edited \*\*is\*\* the broken call, and unresolved edges are never dropped by a node limit, so truncation can't hide your bug from you.
\- \*\*Baseline diffing.\*\* Trace before you edit, hand the whole result back as \`baseline\` after, and it reports exactly which edges appeared, disappeared, or changed. You see the call you accidentally severed \*before\* you compile. That replaces "build, wait, guess, repeat" with one call.
\- \*\*\`view=data\`\*\* answers a completely different question — which functions read, write, or mutate \`m\_something\`. That's how you find the code corrupting state, rather than the code calling a function.
\- \*\*Fan-out through interfaces\*\* expands to every implementation, so a virtual dispatch shows all its arms instead of one.
\- \*\*Thread edges\*\* mark where execution leaves the current thread.
\- It indexes \*\*only what the build actually compiles\*\* (\`compile\_commands.json\`), because code in no target cannot run, and its symbols are otherwise indistinguishable from live ones. Analysis always covers the whole project; \`files\` narrows only the \*report\* — because the breakage is usually in a dangling caller you didn't touch.
\## 5. My directive vs. a "helpful assistant"
| Generic "helpful assistant" | My ELARA directive |
|---|---|
| Answers from recall | \*\*Lookup first\*\*: if I can't state an API from a source I read \*this session\*, I go read it. Guessing an interface when a reference was one call away is classed as a \*process defect\*, even when the guess works |
| Sounds confident when uncertain | \*\*Honesty is absolute\*\* — deliver \`PARTIAL\` or \`BLOCKED\` with file/line evidence, never dress up half-work as complete |
| Polishes endlessly | \*\*Governor\*\*: the completion test is \*"would stopping now leave a usable, correct result?"\* Out-of-scope niceties get one line under \*Unaddressed findings\*, not a refactor |
| Ships vague numbers | \*\*The sandbox is free, inference arithmetic is not\*\* — script it, run it, save the file, read it back. Never derive the same figure twice |
| Vague about time | \*\*Clock rule\*\*: no time value without a system stamp. No stale stamp reused as "now", no invented overrun silently cutting scope |
| Treats all bugs as equal | \*\*Defects in the requested path are the job whatever the clock says\*\*; polish nobody asked for is a footnote |
| Ignores its environment | Owns \`.elana-ignore\` proactively — an unmarked build directory costs its file count \*every turn of every future session\* |
The strongest point is the one that just fired: a "helpful assistant" would have told you about the PLE fix in your launch script. I checked whether the script \*applies\* it.
\## 6. One thing worth your attention
\`run-testBuild-qwen38-heretic2-mtp-Q4\_K.sh\` documents \`PLE=gpu\` in its header as \*"the performance fix… 53.7 → 63.0 t/s, CPU\_Mapped 51,880 MiB → 0"\*, but \*\*its \`exec\` line has no \`--override-tensor\` at all\*\* — the only \`-ot\` matches in that file are comment lines 17 and 19. The implementation lives in \`run-PLE-qwen38-heretic2-mtp-Q4\_K.sh:125-127\`. The running process confirms it: no \`--override-tensor\` in \`/proc/436345/cmdline\`, so \*\*the PLE table is on CPU right now\*\*, and the header's own reasoning says that means lazy row re-reads from disk every decode step. Also stale: the header says \`--mirostat-ent\` is "left at 5.0", while the exec line uses \`2.0\`. I haven't changed anything — it's your launch config and there's a dedicated script for it.
\---
\`\`\`
TIME\_AWARENESS:
\- Start: Wed 30 Sep 2026 05:45:49 CEST End: 05:47:16 CEST Elapsed: \~1m27s
\- Clock calls: 1 get\_datetime; every other stamp read off tool results. No fabricated time.
\- Rough estimate: 2-4 min, read-only intro needing code+hardware lookups. Actual \~1.5 min.
Faster than estimated because hardware, running cmdline, metrics and patch state
each came back in one batched shell call.
\- Complexity read: presentation task gated on evidence-gathering, not a code change.
\- Time checks: 4 (all tool-result stamped). Lookups: 7 tool calls, 0 reasoning-only guesses.
\- Thrash events: none. Sandbox: /home/llama-pr27836/REPL\_sandbox/intro\_metrics.txt — KEPT
(the established findings dir; re-run the python one-liner to refresh the counters).
\- Scope locked: yes. In-scope defects: none (no code changed). Delivery: COMPLETE.
\`\`\`
\*\*Unaddressed findings:\*\*
\- \*\*\[MEDIUM\]\*\* \`run-testBuild-qwen38-heretic2-mtp-Q4\_K.sh\` — documented \`PLE=gpu\` fix never applied; running server has PLE on CPU. \*Why not fixed:\* you described this config as intentional, and the fix changes VRAM placement and throughput characteristics; \`run-PLE-\*.sh\` already implements it correctly. \*Next step:\* port lines 101–127 of the PLE script into this launcher, or delete the stale header block.
\- \*\*\[LOW\]\*\* Same file, header says \`--mirostat-ent\` is left at \`5.0\`; exec uses \`2.0\`. \*Why not fixed:\* comment-only, and the value in use is the better one. \*Next step:\* correct the comment.
Shall I close that PLE gap and measure it, or would you rather I put these tools to work on something else?