quiver — Visualize 2-D vector fields with quiver plots in MATLAB and RunMat.

quiver visualizes 2-D vector fields as arrows anchored at data points. Supported call forms, scaling behavior, and returned handle semantics follow MATLAB behavior.

Syntax

h = quiver(U, V)
h = quiver(X, Y, U, V)
h = quiver(X, Y, U, V, LineSpec)
h = quiver(X, Y, U, V, Name, Value, ...)
h = quiver(ax, U, V)
h = quiver(ax, X, Y, U, V)
h = quiver(ax, X, Y, U, V, LineSpec)
h = quiver(ax, X, Y, U, V, Name, Value, ...)

Inputs

Returns

Errors

How quiver works

• quiver(U, V) builds the default coordinate grid from the shape of U and V.
• quiver(X, Y, U, V) accepts explicit coordinate vectors or meshgrid-style axes, depending on the input layout.
• The returned value is a quiver-handle object that can be queried and updated through get and set.
• Auto-scale factor, head size, line width, color, and display-name workflows are all part of the plotting property path.
• Dedicated GPU geometry generation keeps vector-field rendering on device when plotting-compatible buffers are available.

Options

• 'AutoScaleFactor' / 'Scale' controls arrow scaling.
• 'MaxHeadSize' / 'HeadSize' controls the size of arrowheads.
• Line-style color and width workflows are supported through the same style parsing and handle/property path used by other line-like plots.

Does RunMat run quiver on the GPU?

The direct quiver path emits renderer-ready arrow geometry from GPU buffers on the happy path.

Axes-local state, handle/property workflows, and replay/export behavior stay aligned across GPU and fallback rendering paths.

GPU memory and residency

quiver preserves GPU residency on the direct path by building arrow geometry from exported GPU buffers. If the direct geometry path is unavailable for the active input combination, RunMat falls back while preserving the same quiver semantics and handle behavior.

Examples

Create a vector field from U and V only

[X, Y] = meshgrid(-2:0.5:2, -2:0.5:2);
U = -Y;
V = X;
quiver(U, V);

Expected output:

% RunMat infers the coordinate grid from the vector-field shape

Provide explicit coordinates for a flow field

[X, Y] = meshgrid(-2:0.5:2, -2:0.5:2);
U = -Y;
V = X;
quiver(X, Y, U, V);

Adjust arrow scaling and head size through the handle

[X, Y] = meshgrid(-2:0.5:2, -2:0.5:2);
U = -Y;
V = X;
h = quiver(X, Y, U, V);
set(h, 'AutoScaleFactor', 1.5, 'MaxHeadSize', 0.2, 'DisplayName', 'rotation');
legend;

Gradient vector field over a scalar potential

[X, Y] = meshgrid(linspace(-2, 2, 25), linspace(-2, 2, 25));
Z = X .* exp(-X.^2 - Y.^2);
[DX, DY] = gradient(Z, X(1,2)-X(1,1), Y(2,1)-Y(1,1));

contourf(X, Y, Z, 15);
hold on;
quiver(X, Y, DX, DY, 'k', 'LineWidth', 1);
hold off;

colormap('turbo');
colorbar;
title('Gradient Field over Scalar Potential');
xlabel('x');
ylabel('y');

Using quiver with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how quiver changes the result.

FAQ

h = quiver(X, Y, U, V);
set(h, 'AutoScaleFactor', 0); % raw magnitudes, no auto-scaling

contourf(X, Y, Z);
hold on;
quiver(X, Y, U, V, 'Color', 'k');

Related Plotting functions

More plotting resources

• Choosing the right plot type
• Styling plots and axes
• Plot replay and export
• Complete plotting guide

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how quiver is executed, line by line, in Rust.

• View the source for quiver in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing