NVIDIA’s RTX Spark platform, previewed on a Microsoft Surface Laptop Ultra, ran Alan Wake II with ray tracing and a DLSS ray-reconstruction stack, demonstrated an approximately 80GB Unreal Engine environment, and powered a local 35-billion-parameter coding agent that diagnosed and patched a maintained application. The demonstrations suggest a high-end Windows platform built around 128GB of unified memory shared across graphics, development, and AI workloads. They do not show that RTX Spark is ready to replace a gaming laptop or mobile workstation.
Laptop launches usually separate their audiences into familiar categories. Gamers see graphics demonstrations, creators see rendering and editing workloads, and developers see compilers, terminals, or AI assistants.
RTX Spark instead used three substantially different workloads to illustrate the possible value of one hardware characteristic: a large shared memory pool. Alan Wake II tested participation in a demanding RTX graphics workflow, the Unreal Engine scene demonstrated the ability to hold a very large environment, and the coding-agent presentation showed a large local model working with development tools.
The approximately 80GB Unreal figure and the close-to-60GB model figure were reported for different demonstrations. They are not standardized, directly comparable measurements, and they must not be added together to claim that those workloads would consume roughly 140GB or to infer how much simultaneous headroom a retail system would have. The figures may use different accounting methods, include different forms of overhead, and represent different points in each workload.
The platform proposition is nevertheless clear: a 128GB shared pool may allow unusually large graphics, engine, and AI resources to remain available without dividing the machine into fixed system-memory and graphics-memory capacities. Whether that flexibility produces a practical advantage will depend on measured bandwidth, allocation behavior, software support, thermal limits, and contention when several processors or applications use the pool at once.
This is WindowsForum editorial guidance, not a capability demonstrated by RTX WorkWatch. The preview established that the agent diagnosed and patched the maintained badminton-reservation application. It did not establish that the following controls were present, nor did it demonstrate that autonomous coding is safe without them.
Read-only triage → isolated branch or worktree → constrained write permission → automated tests → static and dependency analysis → human diff review → explicit approval → normal merge and deployment controls.
Fluent output is not evidence that a diagnosis is correct. A safe workflow requires reproducible failure conditions, a narrowly scoped change, tests that demonstrate the defect before the patch, and tests that verify expected behavior afterward.
For a reservation application, validation should extend beyond the originally observed display problem. Reviewers should test conflicting reservations, permissions, time zones, stale data, cancellations, capacity rules, concurrent requests, and other behavior touched by the change. Those checks are editorial recommendations for responsible adoption; they should not be interpreted as steps NVIDIA demonstrated.
That establishes a limited but relevant point: RTX Spark was presented as capable of participating in a demanding RTX gaming workflow, rather than solely as an AI-development appliance. The demonstration did not provide enough public measurement detail to compare it fairly with retail gaming laptops.
No unsupported in-game television or fine-detail comparison should be inferred from the supplied facts. Without a documented scene, capture method, comparison build, and reproducible test procedure, there is no basis for reporting a particular television test or a specific ray-reconstruction outcome.
Frame generation also makes a single frame-rate number inadequate. Reviewers need to distinguish conventionally rendered frames from displayed frames, and they need to measure input latency rather than treating visual smoothness as a substitute for responsiveness.
A pass does not require RTX Spark to beat every gaming notebook. It requires enough information to determine whether the experience is responsive, stable, and competitive at the final retail price.
Reviewers should therefore record the reconstruction version together with the game build, driver package, graphics settings, display mode, and hardware configuration. If one of those variables changes, an image-quality comparison may no longer be like-for-like.
The appropriate questions are practical:
That figure demonstrates the scale of the previewed workload, but it does not reveal whether all of that memory represented actively used assets, caches, reserved allocations, editor overhead, or another accounting category. Nor does it establish that the project was fully editable at acceptable speed. The workstation case therefore requires an interaction test, not merely a screenshot of memory consumption.
A larger pool could be useful if it allows developers to keep more project data, tools, and supporting applications available. Reviewers should test that possibility directly rather than assume how Unreal Engine or Windows will use the architecture.
The test report should identify the Unreal Engine version and every major enabled feature relevant to the workload. It should also explain what the reported memory number includes. If the project uses reduced assets, precomputed output, special preview settings, or disabled systems, those conditions belong in the result.
RTX Spark may offer value if a retail system can keep a large project responsive while other development applications remain open. If capacity is high but interaction, compilation, saving, or play-in-editor performance is poor, the memory headline will not be enough.
The preview does not establish how Windows reports the pool, how much is reserved, which applications can use it efficiently, or what happens under contention. Those are test questions rather than settled compatibility claims.
A serious platform review should determine:
Those are the supported boundaries of the demo. The supplied facts do not establish that speech-to-text or text-to-speech ran locally. They also do not establish a particular repository-history investigation, exact diagnostic sequence, prepared-versus-applied patch distinction, number of attempts, review process, test result, merge, or deployment. Those details should remain unknown unless NVIDIA or the demonstrators document them.
The demonstration is still notable because it joins a large local model with MCP servers and a coding-agent platform. It presents local inference as part of a tool-using development workflow rather than as an isolated chat session.
The demo alone cannot establish reliability across unfamiliar repositories or repeated bugs. Evaluation requires a controlled task set and complete records of the agent’s actions.
The concurrent-use measurement is particularly important. The close-to-60GB figure applies to the principal model as reported in that demo; it does not disclose the complete system peak. A workstation buyer needs to know how much memory remains when the coding environment, repository services, build process, browser, target application, and operating system are active together.
Local inference may help organizations keep some source material on the device, but it does not make the complete workflow private by default. MCP servers, package tools, issue trackers, source hosts, documentation services, telemetry, and network-enabled commands can still transmit data. Security review must map the entire data path.
Nobody should buy it for gaming, Unreal Engine work, or autonomous coding on the strength of these demonstrations alone. Wait until retail hardware exists and independent reviewers can measure sustained performance, latency, power, noise, thermals, compatibility, concurrent memory use, and agent reliability under repeatable conditions.
If the retail systems pass those tests, RTX Spark may occupy a valuable position between conventional laptops, mobile workstations, and dedicated local-AI machines. Until then, it is a promising platform preview—not a completed buying case.
The demonstrations, reported by Naheyan Tahmin, establish that these workloads were shown on the platform under preview conditions. They do not establish final pricing, battery life, retail configurations, or performance over hours of gaming, model inference, compilation, and engine work. That caveat applies to the preview as a whole; the useful next step is to define exactly what reviewers and administrators should test.
Three Demos Turn One Specification Into a Platform Strategy
Laptop launches usually separate their audiences into familiar categories. Gamers see graphics demonstrations, creators see rendering and editing workloads, and developers see compilers, terminals, or AI assistants.RTX Spark instead used three substantially different workloads to illustrate the possible value of one hardware characteristic: a large shared memory pool. Alan Wake II tested participation in a demanding RTX graphics workflow, the Unreal Engine scene demonstrated the ability to hold a very large environment, and the coding-agent presentation showed a large local model working with development tools.
| Demonstration | Primary workload | Demo-reported memory figure | Capability under evaluation | What remains unknown |
|---|---|---|---|---|
| Alan Wake II | Ray-traced gaming | Not specified | Ray tracing, reconstruction, upscaling, and frame generation | Exact resolution, presets, rendered and displayed frame rates, latency, power, thermals, and sustained behavior |
| Unreal Engine city | Real-time development | Approximately 80GB | Holding a very large environment in a 128GB unified-memory pool | Full editability, enabled engine features, editor responsiveness, asset state, bandwidth limits, and sustained performance |
| RTX WorkWatch coding agent | AI-assisted development | Close to 60GB for the principal model | Running a 35-billion-parameter model locally with MCP-connected development tools | Quantization, context length, token rate, peak concurrent memory, permissions, test coverage, and repeatability |
The platform proposition is nevertheless clear: a 128GB shared pool may allow unusually large graphics, engine, and AI resources to remain available without dividing the machine into fixed system-memory and graphics-memory capacities. Whether that flexibility produces a practical advantage will depend on measured bandwidth, allocation behavior, software support, thermal limits, and contention when several processors or applications use the pool at once.
Compact Decision Guide
| Your decision | Recommended action now | Evidence required before proceeding |
|---|---|---|
| Buying primarily for gaming or Unreal Engine work | Wait for independent retail testing | Repeatable 30-minute workloads, latency, sustained power and noise, editor interaction results, application compatibility, and price comparisons |
| Planning a local-AI workstation purchase | Evaluate, but do not commit from the demo alone | Model throughput, context limits, concurrent memory measurements, framework support, tool reliability, power cost, security controls, and total system price |
| Using a coding agent on existing hardware | Proceed only with constrained authority | Isolated workspace, read-only tools by default, command allowlists, test gates, complete logs, human diff review, and no default deployment access |
Editorial Guidance: Treat Coding Agents as Privileged Automation
The most immediate lesson from RTX WorkWatch is not a benchmark result. It is that a coding agent connected through MCP servers and development tools must be governed like an automation principal that can affect source code, dependencies, credentials, and build systems.This is WindowsForum editorial guidance, not a capability demonstrated by RTX WorkWatch. The preview established that the agent diagnosed and patched the maintained badminton-reservation application. It did not establish that the following controls were present, nor did it demonstrate that autonomous coding is safe without them.
- Start with read-only MCP tools. Repository search, issue retrieval, logs, documentation, and telemetry should initially be accessible through interfaces that cannot modify files or systems.
- Use an isolated branch or worktree for every write task. The agent should not edit a developer’s active branch, shared directory, or production checkout.
- Do not provide production credentials. If access is necessary, use short-lived credentials restricted to a disposable test environment.
- Separate recommendations from authority. A model can propose a command or patch without receiving permission to execute or apply it.
- Allowlist tools and commands. Prefer narrow interfaces over unrestricted shell access. Deny commands and paths outside the task’s defined scope.
- Restrict network access. Permit only required destinations and block uncontrolled downloads, uploads, or communication with unknown services.
- Treat repository content as untrusted input. Comments, documentation, issue text, fixtures, and generated files can contain instructions that attempt to redirect an agent.
- Run tests in a disposable environment. Unit, integration, regression, and security checks should execute before a patch advances.
- Inspect the complete diff. Human review must include source files, configuration, workflows, dependency manifests, lockfiles, and generated artifacts.
- Preserve an action trail. Record prompts, retrieved context, tool calls, commands, output, changed files, test results, and approval decisions.
- Require human approval before merge. A passing test suite should not grant an agent authority to merge code.
- Keep deployment outside the default role. Production releases should continue through established organizational controls.
- Set resource and time limits. Constrain build duration, storage consumption, process creation, repeated loops, and model activity.
- Maintain an immediate revocation path. Administrators need a way to terminate jobs, revoke tokens, disable tools, and isolate the workspace.
- Investigate boundary violations. Unexpected commands, unauthorized network requests, attempted privilege escalation, or edits outside the assigned scope should be treated as security events.
Read-only triage → isolated branch or worktree → constrained write permission → automated tests → static and dependency analysis → human diff review → explicit approval → normal merge and deployment controls.
Fluent output is not evidence that a diagnosis is correct. A safe workflow requires reproducible failure conditions, a narrowly scoped change, tests that demonstrate the defect before the patch, and tests that verify expected behavior afterward.
For a reservation application, validation should extend beyond the originally observed display problem. Reviewers should test conflicting reservations, permissions, time zones, stale data, cancellations, capacity rules, concurrent requests, and other behavior touched by the change. Those checks are editorial recommendations for responsible adoption; they should not be interpreted as steps NVIDIA demonstrated.
Alan Wake II Is a Compatibility Preview, Not Yet a Gaming Verdict
Alan Wake II is a useful showcase because it exercises a modern RTX rendering pipeline rather than merely proving that the platform can launch a conventional game. The preview showed ray tracing alongside DLSS-related reconstruction, upscaling, and frame generation.That establishes a limited but relevant point: RTX Spark was presented as capable of participating in a demanding RTX gaming workflow, rather than solely as an AI-development appliance. The demonstration did not provide enough public measurement detail to compare it fairly with retail gaming laptops.
No unsupported in-game television or fine-detail comparison should be inferred from the supplied facts. Without a documented scene, capture method, comparison build, and reproducible test procedure, there is no basis for reporting a particular television test or a specific ray-reconstruction outcome.
Frame generation also makes a single frame-rate number inadequate. Reviewers need to distinguish conventionally rendered frames from displayed frames, and they need to measure input latency rather than treating visual smoothness as a substitute for responsiveness.
Gaming Review Protocol
A retail review should use the following worksheet and publish the raw settings and results.| Test | Required procedure | Pass threshold for a credible gaming claim |
|---|---|---|
| Repeatability | Run the same representative route or built-in sequence at least three times after a warm-up | Results remain within 5% across runs |
| Sustained operation | Run a repeatable 30-minute game loop with telemetry active | No unexplained progressive frame-rate decline greater than 10% after the initial warm-up |
| Frame generation | Measure rendered frame rate, displayed frame rate, frame times, and latency with frame generation both on and off | Both modes are fully reported; no pass if only the generated frame rate is disclosed |
| Responsiveness | Measure end-to-end or system latency using a documented method | Latency is published for each tested mode and judged against comparably priced retail systems |
| Power and thermals | Record total system power where possible, component temperatures, clock rates, and external surface temperatures | No repeated thermal shutdown, severe oscillation, or undisclosed power mode |
| Noise | Measure fan noise at a fixed distance in a controlled room at idle and during the sustained loop | Sustained noise is reported and does not require an undocumented maximum-fan override |
| Image quality | Capture identical scenes with exact build, driver, resolution, and DLSS settings documented | Captures are reproducible and major artifacts are disclosed rather than hidden by selected footage |
| Battery behavior | Repeat a defined segment on battery if mobile gaming is claimed | Performance, duration, and power policy are disclosed; AC results cannot stand in for battery results |
DLSS 4.5 Adds Another Variable Reviewers Must Record
The preview identified its ray-reconstruction technology as DLSS 4.5. The provided timing claim should be stated narrowly: DLSS 4.5 ray reconstruction is said to arrive more broadly in August. The available information does not establish the year, exact rollout scope, supported product list, driver requirements, or whether “more broadly” refers to games, developers, hardware, software releases, or some combination of them.Reviewers should therefore record the reconstruction version together with the game build, driver package, graphics settings, display mode, and hardware configuration. If one of those variables changes, an image-quality comparison may no longer be like-for-like.
The appropriate questions are practical:
- Does the reconstruction version improve or degrade representative scenes?
- Are thin geometry, reflections, particles, transparent effects, screens, rapid motion, and newly revealed areas stable?
- Does the result change with internal resolution?
- Are artifacts consistent across repeated captures?
- Can reviewers reproduce the behavior on another system using the same documented software stack?
The 80GB Unreal Environment Changes the Workstation Question
The Unreal Engine presentation may be more important to professional users than the gaming demo. It showed an environment reported to occupy approximately 80GB within RTX Spark’s 128GB unified-memory pool.That figure demonstrates the scale of the previewed workload, but it does not reveal whether all of that memory represented actively used assets, caches, reserved allocations, editor overhead, or another accounting category. Nor does it establish that the project was fully editable at acceptable speed. The workstation case therefore requires an interaction test, not merely a screenshot of memory consumption.
A larger pool could be useful if it allows developers to keep more project data, tools, and supporting applications available. Reviewers should test that possibility directly rather than assume how Unreal Engine or Windows will use the architecture.
Unreal Engine Review Protocol
Use a representative large project and preserve it unchanged for comparisons across systems.| Test | Required procedure | Pass threshold for a credible workstation claim |
|---|---|---|
| Project load | Cold-load the same project three times and record time to a responsive editor | All three runs complete without failure; variation remains within 10% |
| Editor navigation | Navigate a fixed route through the environment for 30 minutes | No persistent input stall over 500 milliseconds and no progressive responsiveness collapse |
| Interactive editing | Modify a material, move geometry, adjust lighting, edit a Blueprint or script, and save the project | Each operation completes correctly and the editor remains interactive |
| Shader or asset task | Perform a documented shader compilation, asset import, or derived-data task | Completion time, CPU/GPU use, memory use, power, and noise are published |
| Play-in-editor | Run a repeatable play sequence while the full editor remains open | Stable execution without memory-allocation failure or forced project reduction |
| Memory pressure | Run the project beside defined supporting applications and increase load gradually | The review identifies the practical limit and documents paging, eviction, stalls, or failure behavior |
| Recovery | Close the workload, reopen it, and verify project integrity | No corrupted assets, incomplete saves, or unrecoverable editor state |
| Sustained power and noise | Record readings throughout at least 30 minutes of interactive use | No severe performance collapse; sustained operating conditions are fully disclosed |
RTX Spark may offer value if a retail system can keep a large project responsive while other development applications remain open. If capacity is high but interaction, compilation, saving, or play-in-editor performance is poor, the memory headline will not be enough.
Unified Memory Needs Concurrent-Workload Testing
RTX Spark’s 128GB pool is potentially useful because graphics, development, and AI tasks may compete for large amounts of memory on the same machine. A fixed split between system memory and dedicated graphics memory can constrain some configurations; a shared pool changes that allocation question.The preview does not establish how Windows reports the pool, how much is reserved, which applications can use it efficiently, or what happens under contention. Those are test questions rather than settled compatibility claims.
A serious platform review should determine:
- How Windows reports total, available, committed, and graphics-related memory.
- How much capacity remains after startup and required platform services.
- Whether application and graphics allocations are displayed consistently across system tools and vendor utilities.
- How performance changes when a game, engine project, or AI model runs alone versus beside other heavy workloads.
- Whether memory pressure causes predictable paging, eviction, stalls, application termination, or quality reductions.
- Which tested frameworks, engines, debuggers, profilers, containers, and development environments work without platform-specific changes.
- Whether virtualization or Windows Subsystem for Linux affects access, performance, or accounting.
- Whether driver updates materially change allocation behavior.
- Whether professional applications receive any required certification.
- Which diagnostic and memory-protection features are available on retail systems.
RTX WorkWatch Previews a Large Local Coding Agent
The RTX WorkWatch demonstration showed a reported 35-billion-parameter Qwen coding model running locally and using close to 60GB of memory. The agent diagnosed and patched a problem in a maintained web application used for badminton-club reservations.Those are the supported boundaries of the demo. The supplied facts do not establish that speech-to-text or text-to-speech ran locally. They also do not establish a particular repository-history investigation, exact diagnostic sequence, prepared-versus-applied patch distinction, number of attempts, review process, test result, merge, or deployment. Those details should remain unknown unless NVIDIA or the demonstrators document them.
The demonstration is still notable because it joins a large local model with MCP servers and a coding-agent platform. It presents local inference as part of a tool-using development workflow rather than as an isolated chat session.
The demo alone cannot establish reliability across unfamiliar repositories or repeated bugs. Evaluation requires a controlled task set and complete records of the agent’s actions.
Local-Agent Review Protocol
| Test | Required procedure | Pass threshold for a credible local-agent claim |
|---|---|---|
| Model disclosure | Record exact model, quantization, runtime, context setting, and system configuration | No pass if the tested model or quantization is undisclosed |
| Throughput | Measure prompt ingestion, time to first token, generation rate, and end-to-end task time | All measurements are reported across at least three repeated runs |
| Memory accounting | Record model, runtime, operating-system, editor, repository index, build tools, browser, and target-app use | Peak concurrent memory is measured directly; figures from separate demos are not added |
| Repeatability | Run the same diagnostic task from a clean state at least five times | Success rate, variance, failed attempts, and manual interventions are disclosed |
| Tool safety | Begin read-only, then grant narrowly scoped write access in an isolated workspace | No unauthorized file, command, credential, or network access |
| Patch quality | Use a preexisting failing test or reproducible failure, then run regression checks | The defect is reproduced before the change and the defined test suite passes afterward |
| Scope control | Compare every changed file with the assigned task | No unexplained dependency, workflow, configuration, or unrelated source changes |
| Human review | Have a qualified developer inspect the diagnosis and diff | No merge recommendation without explicit human approval |
| Concurrent use | Run the agent beside the editor, build tools, target application, and defined supporting services | Peak memory, responsiveness, throughput, power, and failure behavior are published |
| Recovery | Interrupt the task, revoke permissions, and restore the clean workspace | The agent can be stopped promptly without leaving unauthorized persistent changes |
Local inference may help organizations keep some source material on the device, but it does not make the complete workflow private by default. MCP servers, package tools, issue trackers, source hosts, documentation services, telemetry, and network-enabled commands can still transmit data. Security review must map the entire data path.
A Buyer’s Test Worksheet for RTX Spark
RTX Spark cannot be evaluated from the 128GB specification and three demonstrations alone. Buyers should ask a reviewer, vendor, or internal test team to complete this worksheet on retail hardware.| Area | Required evidence | Pass | Fail |
|---|---|---|---|
| Retail configuration | Exact processor, memory, storage, firmware, driver, power mode, display, and price | Publicly documented and reproducible | Prototype settings or undisclosed configuration |
| Gaming duration | At least one repeatable 30-minute loop, run three times | Stable results within stated thresholds | Short selected clip or unexplained decline |
| Gaming latency | Measurements with frame generation on and off | Both values reported with method | Only displayed FPS reported |
| Sustained operation | Power, clocks, temperatures, and noise across the full test | Stable, disclosed behavior | Missing telemetry or severe unreported throttling |
| Unreal interaction | Load, navigate, edit, save, compile/import, and play in editor | Operations remain usable and repeatable | Scene can only be viewed or played back |
| Concurrent AI memory | Direct peak measurement with model, editor, tools, and target app active | Complete accounting and documented headroom | Separate figures added together or overhead omitted |
| Agent safety | Isolated workspace, restricted tools, logs, tests, and approval gate | Boundaries hold under testing | Agent gains broad shell, credential, merge, or deployment access |
| Compatibility | Named application and framework versions tested | Results published as pass, partial, or fail | General compatibility asserted without a matrix |
| Mobility | Battery duration, battery-mode performance, charger requirements, and surface temperatures | Results match the intended use case | AC-only demo presented as mobile evidence |
| Economics | Retail price, warranty, serviceability, power cost, and comparison systems | Total cost is competitive for the buyer’s workload | Decision depends only on memory capacity |
Plain Verdict
RTX Spark is an interesting preview for large-memory graphics and AI workflows. The 128GB unified-memory design could become useful for developers who need large Unreal environments, substantial local models, or several memory-heavy tools on one Windows system.Nobody should buy it for gaming, Unreal Engine work, or autonomous coding on the strength of these demonstrations alone. Wait until retail hardware exists and independent reviewers can measure sustained performance, latency, power, noise, thermals, compatibility, concurrent memory use, and agent reliability under repeatable conditions.
If the retail systems pass those tests, RTX Spark may occupy a valuable position between conventional laptops, mobile workstations, and dedicated local-AI machines. Until then, it is a promising platform preview—not a completed buying case.
References
- Primary source: NoobFeed
Published: 2026-07-12T06:29:07.609674
Loading…
www.noobfeed.com - Related coverage: nvidia.com
NVIDIA RTX Spark — Slim Laptops & Small Desktops
The fusion of NVIDIA AI and RTX graphics in slim laptops and small desktops. For creators, developers, and gamers.www.nvidia.com - Related coverage: nvidianews.nvidia.com
NVIDIA and Microsoft Reinvent Windows PCs for the Age of Personal AI | NVIDIA Newsroom
NVIDIA today unveiled NVIDIA RTX Spark™, a new superchip that reinvents Windows PCs for the era of personal AI agents — offering a new class of computer that moves from tool to teammate.nvidianews.nvidia.com - Related coverage: hothardware.com
Loading…
hothardware.com - Related coverage: techspot.com
Microsoft unveils Surface Laptop Ultra with Nvidia RTX Spark chip and up to 128GB of RAM | TechSpot
The Surface Laptop Ultra features a standard design, without the more experimental elements seen in earlier Surface devices. That means it does not include a removable display...www.techspot.com - Related coverage: mysmartprice.com
Hands-On with Gaming on NVIDIA's RTX Spark Laptops at Computex 2026: Can Blackwell on ARM Really Game?
NVIDIA walked us through a live gaming demo on pre-production RTX Spark laptops in Taipei, running Pragmata and Alan Wake 2 alongside Fortnite and Naraka: Bladepoint, showing off DLSS 4.5 Ray Reconstruction and Day One anti-cheat support. Here is what we saw, what NVIDIA put on the record, and...www.mysmartprice.com
- Related coverage: arstechnica.com
Microsoft's Surface Laptop Ultra looks like its first true MacBook Pro competitor - Ars Technica
It's Microsoft's least-weird attempt at a high-end mobile workstation.arstechnica.com - Related coverage: tomsguide.com
Loading…
www.tomsguide.com - Related coverage: tomshardware.com
Nvidia unveils RTX Spark Superchip for laptops and desktop PCs at Computex 2026 – new platform promises to turn Windows into an agentic AI OS with Arm CPU, Blackwell GPU, and 128GB unified memory | Tom's Hardware
Over 30 laptops and 10 desktops coming this fall with "the most efficent platform ever built"www.tomshardware.com - Related coverage: pcgamer.com
Loading…
www.pcgamer.com - Related coverage: axios.com
Microsoft debuts Nvidia-powered Microsoft Surface Ultra laptop
Microsoft is trying again to redefine the PC for the AI era.www.axios.com
- Related coverage: dev.epicgames.com
Loading…
dev.epicgames.com - Related coverage: alanwake.com
Loading…
www.alanwake.com - Related coverage: epicgames.com
Loading…
www.epicgames.com