SC105 — 96-Core CFD HPC Node with 384 MB Cache and 12-Channel Memory for ANSYS Fluent

The SC105 node is the largest single-socket configuration in the lineup. It runs a single AMD EPYC 9655 — 96 cores and 192 threads at a 4.1 GHz all-core boost — with 384 MB of L3 cache and twelve DDR5 memory channels behind it. AMD lists CFD and HPC as primary target workloads for this chip. Paired with 128 GB of RAM and 2 × 1.88 TB NVMe SSD, it delivers cluster-scale parallelism from one machine, with no network between ranks.

This is also the tier where sizing matters most. Ninety-six cores only pays off on a case genuinely big enough to fill them — read the section below before choosing it.

Specifications

Ninety-six cores in a single socket is the widest parallel spread available here, backed by 384 MB of L3 — the largest cache in the lineup — and roughly 600 GB/s of memory bandwidth across twelve channels. The 4.1 GHz figure is the all-core boost, held with every rank loaded, not the 4.5 GHz single-core peak.

Sizing note: read this first

SC105 carries 128 GB of RAM across 96 cores — around 1.3 GB per core. That's the tightest core-to-memory ratio in the lineup, and it defines what this node is for: solving cases that fit comfortably in 128 GB as fast as physically possible on one socket. It is a pure throughput node, not a capacity node.

That creates a narrow but real sweet spot. Your case needs enough cells to keep 96 partitions genuinely busy, while still fitting in 128 GB. As a rough guide, Fluent needs about 1 GB of RAM per million cells for a typical steady single-phase case — so a mesh in the upper part of what 128 GB holds, on simpler physics, is where SC105 earns its keep. Heavier physics reduces the cell count that fits, which in turn reduces cells per rank, so this node suits large-but-lean cases better than smaller-but-heavier ones.

If your mesh needs more than 128 GB, more cores won't help — our high-memory nodes are the right tool. If your case is moderate in size, a 16-, 24-, or 32-core tier will very likely finish it sooner. Send us your case and we'll tell you honestly which applies.

What this node is built for

SC105 is the maximum-parallelism tier. It suits:

• Large cases that scale well past 64 cores — 96 MPI ranks split a mesh finer than anything else here, and with 600 GB/s of bandwidth behind them, that converts into real wall-clock savings.

• Time-critical turnaround on big runs — when a job that would take a week on a smaller node has to finish over a weekend.

• Bandwidth-heavy physics at scale — coupled solvers, multiphase, combustion: cases moving large volumes of data per iteration.

• Cluster-scale jobs without a cluster — 96 ranks on one socket, with no network hop between them and no MPI-over-network tuning to manage.

• Large parameter sweeps — or several moderate cases run concurrently on partitioned core groups, which on this node is often more efficient than one case spread across all 96.

• Transient, LES, and DES runs writing heavy data — NVMe storage keeps large data files and frequent autosaves from slowing down the solve.

Choosing SC105

Choose SC105 when all three hold:

• Your case has the cell count to keep 96 partitions genuinely busy, and

• It fits within 128 GB, and

• Your bottleneck is throughput rather than single-thread speed or memory capacity.

Fluent scales well only while each core still has enough cells to stay busy relative to the boundary data it exchanges with its neighbors, and at 96 ranks that threshold is high. Split a moderate case this many ways and communication overhead can exceed the solving work entirely — a case where a 24-core node would finish first and a high-clock 8-core node might beat both. On no other tier is the gap between a well-sized and poorly-sized case this large.

One practical alternative worth knowing: if you're running several cases rather than one large one, SC105 can run them concurrently on separate core groups. That often extracts more value from 96 cores than forcing a single case to scale across all of them.

Fast NVMe storage

The two 1.88 TB NVMe SSDs give substantially higher read/write throughput than SATA SSDs, plus nearly 3.76 TB of combined capacity — which matters most on the highest-throughput node in the lineup, where a fast solve shouldn't be held up waiting on disk. That means faster loading of large case and data files, quicker autosaves, and room to keep a full DOE sweep's output on disk without constantly clearing space.

How parallel solving works on this node

When you run Fluent in parallel, the solver partitions your mesh across all 96 cores (using algorithms such as METIS), each core solving its share of cells and exchanging boundary data each iteration via MPI. Running 96 ranks on a single socket is a genuine structural advantage over spreading the same job across networked machines: all that communication stays on fast internal channels instead of crossing a network, so parallel overhead stays lower at a rank count where network latency would otherwise dominate. Between exchanges, twelve memory channels and 384 MB of shared L3 keep the cores fed rather than stalling.

Why rent instead of buy

A 96-core server is a serious capital purchase, and most CFD work doesn't need one continuously. Renting gives you the throughput on the jobs that call for it and lets you drop back to a smaller tier for everything else — which, for most workloads, is most of the time.

How it works — you're in full control

SC105 is yours to drive directly. You connect to the node over a secure remote desktop connection and run everything yourself, exactly as you would on a local workstation:

1. Connect via remote desktop — you get full remote access to the SC105 node.

2. Set up your simulation — load your geometry and case, configure your solver settings, and run ANSYS Fluent with all 96 cores at your command.

3. Run and monitor in real time — start, pause, adjust, and watch the solution as it progresses, with complete control throughout.

4. Keep your results — post-process on the node or download your solution and data files whenever you're ready.

You have full authority over the node for the duration of your rental: we provide the hardware and the support, and you run the simulations your way.

Frequently asked questions

How is SC105 different from our 64-core node? Half again as many cores and 50% more cache on the same 12-channel platform — but a slightly lower all-core clock (4.1 vs. 4.2 GHz) and the same total memory bandwidth shared among more cores. SC105 wins only on cases that genuinely scale past 64 ranks; below that, the 64-core node is faster per core and better matched on memory.

Will 96 cores always be faster? No — and on this tier that's the most likely outcome for a typical case. Fluent scales well only while each core has enough cells to stay busy relative to the data it exchanges with its neighbors. Most CFD cases stop scaling well before 96 ranks. Send us your case and we'll check before you book.

Is 128 GB enough memory for 96 cores? For cases that fit in 128 GB, yes — that's what this node is sized for. At roughly 1.3 GB per core, it's a throughput node, not a capacity node. If your mesh needs more memory, adding cores won't help; our high-memory nodes are the right tier.

Can I run several cases at once instead? Yes, and on this node it's often the better use of 96 cores — running multiple moderate cases concurrently on separate core groups typically extracts more total throughput than forcing one case to scale across all of them.

Is 4.1 GHz slow compared to a 5.7 GHz node? On a single thread, yes. But 5.7 GHz figures are single-core peaks that come down under load. SC105's 4.1 GHz is the all-core number, held with all 96 cores working.

Is my data kept confidential? Yes.

Get started with SC105

If your cases are large, genuinely scale to very high core counts, and fit within 128 GB, SC105 gives you cluster-scale parallelism from a single node.

Contact MR CFD to run your ANSYS Fluent case on SC105 — and we'll confirm your case can actually use 96 cores before you book, or point you to the tier that will solve it faster.