Unlocking 3D Game Development with libGDX: A Comprehensive Guide

Yes—libGDX is suitable for 3D game development. It provides cameras, meshes, models, materials, lighting, animation, batching, asset loading, input, audio, and optional Bullet physics across desktop, Android, HTML5, and iOS. The important qualification is that libGDX is a Java game-development framework, not a Unity-style visual editor. You get portability and code-level control, but you must assemble more of the scene, asset, physics, tooling, and deployment architecture yourself.

As of August 18, 2026, the current stable release is libGDX 1.14.2, released June 5, 2026. This guide explains what its 3D stack does, how to create a first scene, where the difficult parts begin, and when an editor-first engine such as Godot or Unity is a better choice.

#	Preview	Product	Price
1		PNY NVidia Quadro K1200 (Low Profile) PCIE 2.0 x 16 DP Graphics Cards VCQK1200DP-PB	$118.00	Buy on Amazon
2		ARDIYES GT 740 4GB GDDR5 Low Profile GPU Graphics Card, 4X HDMI Ports for Quad Multi-Monitor Setup,...	$82.99	Buy on Amazon
3		msi Gaming GeForce GT 1030 4GB DDR4 64-bit HDCP Support DirectX 12 DP/HDMI Single Fan OC Graphics...	$119.99	Buy on Amazon
4		ASRock Intel Arc Pro B60 Creator 24GB Graphics Card, Workstation GPU, Xe2-HPG, 2400MHz, 24GB GDDR6...	$649.99	Buy on Amazon

What is libGDX?

libGDX is an open-source, Apache 2.0-licensed framework for building games in Java and sharing core game code across multiple platforms. Its official repository describes it as an OpenGL/OpenGL ES-based framework for desktop, Android, HTML5, and iOS development. Gradle manages the project dependencies and platform modules.

A generated project normally puts shared game code in core, with separate launcher or backend modules such as lwjgl3, android, html, and ios. The exact modules depend on the platforms selected during generation. This means “cross-platform” means substantial code sharing—not identical packaging, SDK requirements, APIs, or testing on every target.

#1 Best Overall

PNY NVidia Quadro K1200 (Low Profile) PCIE 2.0 x 16 DP Graphics Cards VCQK1200DP-PB

• Four Mini DisplayPort 1.2 Connectors
• The NVIDIA Quadra K1200 offers incredible 3D application performance in a compact footprint.
• 3-Year Warranty

$118.00

Buy on Amazon

libGDX supplies the foundations:

• Rendering through OpenGL and OpenGL ES.
• 2D and 3D mathematics, meshes, textures, cameras, and transforms.
• Model loading, materials, animation, and model batching.
• Input, audio, file access, application lifecycle, and screen management.
• Optional extensions such as Bullet 3D collision detection and rigid-body physics.
• Platform backends for Windows, Linux, macOS, Android, browsers, and iOS.

It does not automatically provide a visual scene editor, prefab workflow, terrain authoring suite, navmesh editor, cinematic timeline, visual scripting system, or a complete content-production pipeline.

The official wiki is community-driven, so examples and guidance should be checked against the selected libGDX and Java versions.

Is libGDX good for 3D games?

It is a good fit when you want a programmable, relatively lightweight framework and are comfortable building systems around it. It can render stylized and technically sophisticated 3D games, but it does not remove the engineering involved in making a complete game.

The distinction matters: 3D rendering is not the same thing as a complete 3D production environment. A rotating cube demonstrates that libGDX can draw 3D geometry. A shippable game also needs asset preparation, scene organization, animation state, collision rules, save data, UI, profiling, memory management, and platform deployment.

Setting up a libGDX 3D project

Install the required tools

A practical baseline is:

• A supported JDK matching the project template.
• gdx-liftoff, the current libGDX project generator.
• IntelliJ IDEA or Android Studio.
• Android Studio and the Android SDK if Android is a target.
• Blender or another digital-content-creation tool for models, rigs, and animations.
• Git for source control.
• Optionally, an image or texture editor, profiler, and physics-debugging tools.

Do not automatically select the newest JDK. The official project-generation documentation lists baseline Java recommendations that vary by target. gdx-liftoff separately documents newer, advanced Java 25/26 configurations for desktop and related LWJGL compatibility considerations. Treat those notes as version-specific rather than universal requirements.

If Android is required, use the current Android Studio installation guidance for SDK and system requirements. For iOS compilation, you need macOS and Xcode.

Generate the project with gdx-liftoff

Download the JAR from the gdx-liftoff releases page. If double-clicking does not open it, run it from a terminal:

java -jar gdx-liftoff-x.x.x.x.jar

Replace the placeholder with the downloaded filename. In the generator, choose:

• A valid project name and reverse-domain package such as com.example.threedemo.
• Core and Desktop/LWJGL3 first.
• Android only when Android is an immediate target.
• HTML only when browser deployment matters.
• iOS only when you have macOS and Xcode available.
• Bullet only if physics is needed early.
• A minimal or simple game template.

GUI assets are useful if you plan to use Scene2D UI. Avoid selecting every extension immediately: each dependency adds build, compatibility, and troubleshooting surface area.

Open the generated directory as a Gradle project. A typical layout includes:

gradle.properties
settings.gradle
build.gradle
gradlew
gradlew.bat
assets/
core/
lwjgl3/
android/
html/
ios/

Only selected platform directories are generated. Run the desktop target with:

./gradlew lwjgl3:run

On Windows:

gradlew.bat lwjgl3:run

If the generated project uses a different task or module name, follow its README and Gradle files rather than copying a command from an older tutorial.

The libGDX 3D rendering pipeline

The basic flow is:

Asset file
   ↓
Model
   ↓
ModelInstance + transform
   ↓
ModelBatch + camera + environment
   ↓
Shader
   ↓
GPU frame

The important classes

• PerspectiveCamera provides a conventional perspective view. Use it for most 3D games.
• OrthographicCamera is useful for 2.5D, isometric, and strategy views.
• Model is reusable asset data: a hierarchy of nodes containing geometry and materials.
• ModelInstance is a renderable occurrence of a model, with its own world transform and usually its own per-instance animation state.
• ModelBatch submits model instances for rendering using an appropriate shader provider.
• Environment supplies ambient information and lights.
• DirectionalLight, PointLight, and SpotLight represent common light types.
• Material stores surface properties such as diffuse, specular, texture, and shininess attributes.
• AssetManager centralizes loading and reuse of models, textures, and other assets.
• ModelBuilder, MeshBuilder, MeshPartBuilder, and Mesh support procedural and low-level geometry.
• Vector3, Quaternion, and Matrix4 represent positions, rotations, and transforms.

The official model documentation emphasizes the difference between reusable Model data and independent ModelInstance objects. A common performance-friendly pattern is to load one model and create many instances rather than loading the same model repeatedly.

Material data is not the shader

A material describes surface data; a shader determines how that data becomes pixels. Adding a light does not automatically provide physically based rendering, realistic shadows, post-processing, or a particular BRDF. Advanced visual requirements may require a compatible shader provider, custom shaders, or a third-party rendering library.

Rank #2

ARDIYES GT 740 4GB GDDR5 Low Profile GPU Graphics Card, 4X HDMI Ports for Quad Multi-Monitor Setup, PCI Express 3.0 x16, Silent Cooling, Ideal for Office and Home Theater

• Robust 4GB Memory & Quad Display Ready: Equipped with 4GB of fast GDDR5 memory to smoothly handle daily graphics tasks. Features four built-in HDMI ports, enabling a seamless quad-monitor setup directly out of the box—perfect for multi-tasking offices, digital signage, or trading desks.
• Plug-and-Play Installation & Wide Compatibility: Utilizes a standard PCI Express interface for broad compatibility with most desktop PCs. Offers straightforward plug-and-play installation and stable driver support for modern Windows and Linux operating systems, ensuring a hassle-free setup.
• Quiet, Cool & Compact Design: Engineered with a silent fan and efficient cooling system for near-silent operation, making it ideal for noise-sensitive environments. Its low-profile design fits easily into small form factor cases, with both half-height and full-height brackets included for flexible installation.
• Enhanced Multimedia & Everyday Performance: Delivers smooth 1080P video playback and supports hardware-accelerated decoding, offering an excellent experience for home theater PCs (HTPC). Provides capable performance for everyday applications, multimedia tasks.
• Complete Package & Reliable Support: Includes the graphics card, both low-profile and standard brackets, a quick start guide, and screwdriver, which make it simple and quick setup process.

$82.99

Buy on Amazon

Render your first 3D object

Start with procedural geometry. It removes model-file, texture-path, export, and importer problems from the first test.

public class Game3D extends ApplicationAdapter {
    private ModelBatch modelBatch;
    private Model model;
    private ModelInstance instance;
    private PerspectiveCamera camera;
    private Environment environment;

    @Override
    public void create() {
        modelBatch = new ModelBatch();

        camera = new PerspectiveCamera(
            67f,
            Gdx.graphics.getWidth(),
            Gdx.graphics.getHeight()
        );
        camera.position.set(3f, 3f, 3f);
        camera.lookAt(0f, 0f, 0f);
        camera.near = 0.1f;
        camera.far = 100f;
        camera.update();

        environment = new Environment();
        environment.set(new ColorAttribute(
            ColorAttribute.AmbientLight,
            0.8f, 0.8f, 0.8f, 1f
        ));
        environment.add(new DirectionalLight().set(
            Color.WHITE,
            -1f, -0.8f, -0.2f
        ));

        ModelBuilder builder = new ModelBuilder();
        model = builder.createBox(
            1f, 1f, 1f,
            new Material(
                ColorAttribute.createDiffuse(Color.WHITE)
            ),
            VertexAttributes.Usage.Position |
            VertexAttributes.Usage.Normal
        );
        instance = new ModelInstance(model);
    }

    @Override
    public void render() {
        Gdx.gl.glViewport(
            0, 0,
            Gdx.graphics.getWidth(),
            Gdx.graphics.getHeight()
        );
        Gdx.gl.glClear(
            GL20.GL_COLOR_BUFFER_BIT |
            GL20.GL_DEPTH_BUFFER_BIT
        );

        camera.update();
        modelBatch.begin(camera);
        modelBatch.render(instance, environment);
        modelBatch.end();
    }

    @Override
    public void dispose() {
        modelBatch.dispose();
        model.dispose();
    }
}

This is a teaching example, not a complete production architecture. A real game should add resize handling, input, asset management, separate world systems, and deliberate ownership of disposable resources.

Import models and textures

For authored assets, use Blender or another DCC tool and follow libGDX’s supported model-loading workflow. The 3D graphics documentation covers model loading, Blender workflows, materials, animation, and batching.

Do not assume that the source project format is the best runtime format. Test an exported model in the actual desktop backend and verify:

• Texture paths and filename capitalization.
• Scale and coordinate orientation.
• Normals, winding order, and tangents.
• Skeleton and skin data.
• Animation clips and their identifiers.
• Material properties and shader compatibility.
• Whether resources are external or embedded.

Keep runtime models and textures under assets/ unless you have a deliberate build pipeline. A model can look correct in Blender yet appear black, untextured, incorrectly oriented, or incorrectly scaled in libGDX because the importer and runtime shader interpret its data differently.

Load assets with AssetManager

Loading every model and texture synchronously during gameplay makes loading stalls and duplicate resources more likely. AssetManager provides centralized loading, asynchronous progress, reuse, and a single place to dispose assets.

AssetManager assets = new AssetManager();

assets.load("character.g3db", Model.class);
assets.load("environment.g3db", Model.class);

while (!assets.update()) {
    float progress = assets.getProgress();
    // Draw a loading screen using progress.
}

Model characterModel = assets.get("character.g3db", Model.class);
ModelInstance character = new ModelInstance(characterModel);

In a real screen, call assets.update() from the render loop instead of blocking in a while loop. Dispose the manager when the owning game or loading scope is finished.

When loading fails, inspect the complete asset chain. Missing textures, unsupported material features, incorrect relative paths, and mismatched formats are common causes—not just Java errors.

Cameras, movement, lighting, and materials

Camera setup

Use a perspective camera for most first-person, third-person, action, and exploration games. Tune near and far deliberately: a near plane that is too large clips nearby geometry, while an unnecessarily distant far plane can reduce depth precision. Call camera.update() after changing its position, orientation, viewport, or projection.

For movement, use delta time so speed does not depend on frame rate:

float dt = Gdx.graphics.getDeltaTime();
player.position.mulAdd(direction, speed * dt);

First-person controls typically rotate the camera from mouse or touch deltas. A third-person camera can follow a target with smoothing and collision-aware positioning. When the model has a node hierarchy, animation, or physics body, changing a top-level position is only one part of the transform problem: visual nodes, world transforms, and physics transforms must remain synchronized.

Lighting

Useful starting points include:

• Ambient light for a minimum level of scene visibility.
• A directional light for sunlight or broad illumination.
• Point lights for local sources such as lamps.
• Spotlights for cones such as flashlights.

Begin with ambient light and a simple diffuse material. Add textures, specular values, normal maps, shadows, or custom shaders incrementally. Normal maps and advanced material attributes only work when the selected shader supports them. Also decide how your project handles scale, gamma, and color management rather than assuming that a default material is physically accurate.

Animation and model instances

Imported 3D animation generally consists of keyframes applied to a node hierarchy and, for character animation, a skinned mesh. An animation controller advances clips and manages transitions, looping, and blending.

A sensible state flow might be:

1. Confirm that the exported model contains animation data.
2. Read its animation identifiers.
3. Play an idle clip.
4. Switch to walk or run when velocity crosses a threshold.
5. Blend or transition to attack, jump, or hit states.
6. Return to idle or movement when the action ends.

Each independent character normally needs its own animation state and controller even when all characters share the same underlying Model. Sharing mutable controllers unintentionally can make every character play the same clip or advance together. Root motion also requires an explicit decision: either extract movement from the animation or let gameplay and physics control the character position.

Rank #3

msi Gaming GeForce GT 1030 4GB DDR4 64-bit HDCP Support DirectX 12 DP/HDMI Single Fan OC Graphics Card (GT 1030 4GD4 LP OC)

• Chipset: NVIDIA GeForce GT 1030
• Video Memory: 4GB DDR4
• Boost Clock: 1430 MHz
• Memory Interface: 64-bit
• Output: DisplayPort x 1 (v1.4a) / HDMI 2.0b x 1

$119.99

Buy on Amazon

Add physics with Bullet

The project generator can add Bullet, libGDX’s optional extension for 3D collision detection and rigid-body dynamics. Bullet is a physics library, not a complete gameplay framework. You still need game-object abstractions, collision filtering, trigger handling, body ownership, fixed-step updates, and transform synchronization.

Keep these concepts separate:

• Render mesh: what the player sees.
• Collision shape: the simplified shape used by physics.
• Rigid body: mass, velocity, forces, and physical state.
• Physics world: gravity, collision detection, and simulation.
• Game object: gameplay identity and rules.
• Transform bridge: the code that keeps the body and visual instance aligned.

A robust update order is:

1. Read and accumulate player input.
2. Apply forces or desired velocities.
3. Step the physics world with a controlled or fixed timestep.
4. Read the resulting physics transforms.
5. Update visual ModelInstance transforms.
6. Render.

Use boxes, spheres, capsules, cylinders, and convex hulls wherever possible. Detailed triangle meshes are usually better reserved for suitable static geometry. Common errors include using a render mesh as a dynamic collider, moving a dynamic body by changing only the visual model, mixing units, using unrestricted variable deltaTime, and failing to dispose Bullet objects.

UI and object picking

Scene2D UI

3D rendering and interface rendering are separate layers. A common frame order is:

1. Clear the framebuffer.
2. Render the 3D world with ModelBatch.
3. End the 3D batch.
4. Update and draw a Scene2D Stage.

Use a Scene2D Viewport for responsive layout. Route input deliberately: a Stage can consume mouse or touch events before world controls receive them. For example, ignore camera or movement input while a text field, menu, or draggable UI element has focus.

Picking objects

Convert screen coordinates into a camera ray:

Ray ray = camera.getPickRay(screenX, screenY);

For simple selection, test the ray against transformed bounding boxes or spheres with Intersector.intersectRayBounds. For gameplay-grade selection, a physics raycast can use the same collision representation as the game. Select the closest valid hit rather than stopping at the first object in an arbitrary collection.

Picking bugs commonly come from incorrect viewport coordinates, vertical coordinate inversion, untransformed bounds, misunderstood child-node hierarchies, or expensive per-triangle tests performed across a large scene every frame.

Performance and resource management

libGDX gives you control, which also means you are responsible for making expensive choices visible. Start with measurement rather than assumed frame-rate claims.

• Load one reusable Model and create multiple ModelInstance objects.
• Reuse meshes, materials, textures, batches, environments, and temporary math objects where practical.
• Avoid allocating objects inside render().
• Use frustum culling so off-screen objects are not submitted.
• Reduce mesh complexity and use level-of-detail strategies for distant objects.
• Resize and compress textures appropriately for the target hardware.
• Limit expensive transparency and overdraw.
• Load assets asynchronously and show a loading screen.
• Use simple collision shapes.
• Profile CPU and GPU work separately.
• Test on representative Android hardware instead of relying solely on desktop performance.

Java garbage collection is only part of memory management. Models, textures, meshes, framebuffers, fonts, batches, and Bullet resources can own native or GPU resources and require explicit disposal. A useful ownership rule is: the object that creates a disposable resource should either dispose it or clearly transfer that responsibility to a longer-lived owner.

For advanced desktop setups, the gdx-liftoff documentation notes that Java 25 or newer requires LWJGL 3.4.0 or later, with current configuration defaults using LWJGL 3.4.1 through Gradle constraints. It also discusses a possible Wayland-related reason to use LWJGL 3.3.3 instead. These are version- and environment-dependent compatibility details, not general performance advice.

A maintainable 3D project structure

Once the primitive renders, avoid putting every system in the application class. A practical starting structure is:

core/
  assets/
  entities/
  rendering/
  physics/
  input/
  screens/
  systems/
  ui/
  world/

Possible responsibilities include:

• GameScreen: screen lifecycle and high-level orchestration.
• World: entities, terrain, and world state.
• RenderSystem: camera, visible instances, lights, and batches.
• PhysicsSystem: Bullet world, bodies, and synchronization.
• AssetService: loading and retrieval.
• InputController: keyboard, mouse, touch, and gamepad input.
• AnimationSystem: animation state and blending.
• Hud: Scene2D interface.
• Platform launchers: platform-specific configuration only.

This separation makes it easier to replace a renderer, disable physics on a menu screen, load a different world, or adapt input without turning the launcher into the game.

Deploying across platforms

Desktop

Desktop is the recommended first target because it provides a fast iteration loop and makes it easier to isolate rendering and asset problems. Still test window resizing, fullscreen behavior, input differences, filesystem assumptions, and graphics-driver variations.

Android

Android introduces SDK configuration, device memory limits, touch input, lifecycle interruptions, packaging, and a wider range of GPU capabilities. Desktop success does not prove Android compatibility. Test an actual device early, keep texture memory under control, and avoid desktop-only Java APIs.

HTML5

The official setup documentation warns that GWT-based HTML5 compilation supports only a subset of Java libraries. Avoid unsupported desktop APIs, reflection-heavy libraries, unrestricted file access, and assumptions about threads or filesystem behavior. Treat browser deployment as a target with its own constraints, not merely another desktop export.

Rank #4

ASRock Intel Arc Pro B60 Creator 24GB Graphics Card, Workstation GPU, Xe2-HPG, 2400MHz, 24GB GDDR6 192-bit, PCIe 5.0, 4X DP 2.1, Blower

• System Compatibility Note: 2-slot card, 271x112x39mm, single 8-pin power, 200W TDP. Verify chassis clearance and PSU capacity before purchase.
• Dedicated Support: Please contact us directly through Amazon for any product questions or assistance you may require.
• 24GB GDDR6 on 192-Bit Bus: Massive 24GB memory with 456 GB/s bandwidth – ideal for LLMs, AI inference, 3D rendering, and generative design.
• Intel Xe2-HPG Architecture: Built on Intel's next-gen architecture with 20 Xe cores and 160 XMX engines for AI acceleration (197 INT8 TOPS).
• PCIe 5.0 Support: PCI Express 5.0 x16 interface for maximum bandwidth with the latest workstation platforms.

$649.99

Buy on Amazon

iOS

iOS compilation requires macOS and Xcode. Platform launchers, signing, provisioning, store packaging, and device testing remain platform-specific even when most game logic stays in core.

Common problems and recovery paths

gdx-liftoff will not open

Check java -version, confirm that the download is a JAR rather than an incomplete or renamed file, and verify that a JDK—not only a JRE—is installed. Run it from a terminal so the error remains visible:

java -jar gdx-liftoff-x.x.x.x.jar

Gradle cannot resolve dependencies

Check network and proxy settings, the selected libGDX version, and wrapper permissions. On Linux or macOS:

chmod +x gradlew

Also check that dependencies were added to the correct module. The gdx-liftoff documentation notes that many dependencies belong in core/build.gradle, not only in the root build file.

The model is invisible

First render a procedural box. Then check the camera position, model scale and transform, near and far planes, camera update, viewport, depth buffer clearing, and whether the model is behind the camera. Confirm that modelBatch.begin(camera) surrounds rendering and that end() is called.

The model is black

Check for an Environment and light, usable normals, supported material attributes, a compatible shader, and valid textures. Start with ambient light and a plain diffuse material, then add textures, normal maps, and specular properties one at a time.

Textures are missing

Inspect paths embedded in the model, filename capitalization, relative locations, external versus embedded resources, and whether the importer supports the exported material references. Keep all referenced files under the expected assets path.

Animation does not play

Confirm that the model contains animation data, the clip identifier is correct, the controller is updated every frame, and another state is not replacing the clip immediately. Verify the exported skeleton, skin, node hierarchy, and per-instance controller.

Physics drifts or behaves incorrectly

Check gravity, mass, collision shape, units, fixed timestep, body type, origin alignment, activation, and transform synchronization. Do not move a dynamic object by changing only its visual instance, and dispose all Bullet resources.

Android fails after desktop succeeds

Check the Android SDK path, API and build-tool configuration, Java compatibility, native libraries, asset memory use, and backend-specific code. Consult the current Android Studio documentation instead of relying on old SDK-version instructions.

libGDX versus Godot and Unity

Godot

Godot’s 3D workflow is centered on an integrated editor, scenes, nodes, meshes, cameras, lighting, and physics-oriented tools. It is often a better fit for beginners and small teams that want to prototype visually. The trade-off is learning Godot’s project model and scripting environment rather than Java and libGDX’s APIs.

Unity

Unity is a stronger fit when a team needs a mature editor, integrated production systems, a large plugin ecosystem, and established commercial workflows. As of August 2026, Unity Personal is free for eligible users below the stated $200,000 revenue or funding threshold; Unity Pro is listed at $210 per month, with plan rules and eligibility depending on the business. Confirm current terms, geography, billing, and taxes before making a commercial decision.

Unity’s convenience comes with a different engine architecture, licensing and subscription considerations, and less direct Java integration. It is not automatically better; it solves a different problem.

Licensing and adjacent tools

libGDX itself is Apache 2.0 licensed and free to use in commercial and non-commercial projects. That does not automatically license the assets or dependencies used with it. Check the separate licenses for models, textures, fonts, plugins, third-party libraries, and music.

A practical toolchain can remain free at the beginning:

1. Use libGDX and gdx-liftoff to create the project.
2. Use IntelliJ IDEA’s available free core Java/Kotlin development for a small code-first project, or evaluate Ultimate features if you need them. Check current pricing and eligibility.
3. Install Android Studio when Android deployment is required.
4. Use Blender for modeling, rigging, animation, and asset preparation.
5. Add third-party libraries only after the basic rendering path works, checking maintenance, licensing, platform support, and version compatibility.

A sensible learning and production sequence

1. Generate a minimal Core plus Desktop/LWJGL3 project.
2. Clear the screen and render a procedural box.
3. Add camera movement and frame-rate-independent motion.
4. Load one static model from assets/.
5. Fix scale, orientation, textures, normals, and materials.
6. Move asset loading into AssetManager.
7. Add animation with one independently controlled character.
8. Add collision and Bullet synchronization only when the visual pipeline is stable.
9. Add Scene2D UI and input routing.
10. Implement picking or raycasts where gameplay needs them.
11. Run on the target Android, HTML5, or iOS platform early.
12. Profile CPU, GPU, memory, loading, and native-resource lifetime before content grows.

This sequence keeps failures local. If a primitive works but an imported model does not, the problem is probably in the asset pipeline. If the model renders but movement drifts, inspect transforms and physics rather than project generation.

Quick Recap

Bestseller No. 1

PNY NVidia Quadro K1200 (Low Profile) PCIE 2.0 x 16 DP Graphics Cards VCQK1200DP-PB

Four Mini DisplayPort 1.2 Connectors; 3-Year Warranty

$118.00

Bestseller No. 2

ARDIYES GT 740 4GB GDDR5 Low Profile GPU Graphics Card, 4X HDMI Ports for Quad Multi-Monitor Setup, PCI Express 3.0 x16, Silent Cooling, Ideal for Office and Home Theater

$82.99

Bestseller No. 3

msi Gaming GeForce GT 1030 4GB DDR4 64-bit HDCP Support DirectX 12 DP/HDMI Single Fan OC Graphics Card (GT 1030 4GD4 LP OC)

Chipset: NVIDIA GeForce GT 1030; Video Memory: 4GB DDR4; Boost Clock: 1430 MHz; Memory Interface: 64-bit

$119.99

Bestseller No. 4

ASRock Intel Arc Pro B60 Creator 24GB Graphics Card, Workstation GPU, Xe2-HPG, 2400MHz, 24GB GDDR6 192-bit, PCIe 5.0, 4X DP 2.1, Blower

$649.99

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.