Skip to content

Roadmap ​

The plan of each release is tracked step by step in an issue: v0.1.0 in #1, v0.2.0 in #2, v0.3.0 in #3, v0.3.1 in #5, v0.4.0 in #6, v0.5.0 in #7, v0.6.0 in #10, v0.7.0 in #12, v0.8.0 in #13; each step with its tasks, its checks, the documentation and the pictures it updates, and a log of the work. This page gives what comes next and what is planned, deferred or not planned, then the log of each release, summarised from its issue; the changelog lists the commits.

Next ​

  • The upstream reports of #4, #8, #9 and #11, filed by the owner; FIGURE's patches stay until each lands, then go with the test that needed them kept (#13 S8).
  • Release v0.8.0 (#13 R1): the version and the date are the owner's.

Planned, deferred, not planned ​

ItemStatusWhy, or until when
The items of Nextplannedv0.8.0: #13, #14
The functions listed "raw only" in Dear ImGui names wrappeddeferredUntil an application asks
The whole application compiled to WebAssemblydeferredAn experiment: a patched flang and Emscripten SDL3, no OpenMP and no MPI there
The 3-D view rendered on the GPU in a windowdeferredUntil an application draws more than about 10⁶ triangles in a window (why)
A depth buffer in ImPlot3D's plotsdeferredUntil brenocq/implot3d#151 merges (Known issues)
The showcase's run checker recorded headlessdeferredAfter v0.8.0: it needs figure_time on the capture's clock and a command run at a frame of a recording, two capture features for one picture (Showcase)
Multi-viewports: windows dragged out of the main windowdeferredUntil an application asks: window mode only, remote and headless modes cannot have them (Known issues)
A WebGL renderer of the 3-D view in the browsernot plannedA third renderer, and no pixels on the program's side for tests and captures (why)
Dear ImGui's context thread-localnot plannedA crash in place of a race, not a refusal (Known issues)
Callbacks into Fortran: custom axis scales and tick formattersnot plannedFIGURE calls no Fortran from C; formats, ticks and fixed scales cover them as data (Plots)
The raw bindings called by applicationsnot plannedThe generated layer is internal (Raw bindings)

Release logs ​

The milestones before v0.1.0, then one section per release, oldest first.

M1: build chain and first widgets — done on Linux ​

  • Native layer: CMake, pinned sources, static libfigure_native.a and libSDL3.a.
  • Fortran: figure_app (loop, lazy redraw), figure_imgui (windows, button, check box, sliders for int32, real32, real64, numeric input, text, same line, separator, demo window, window placement, item rectangle), figure_implot (plot, axes, line).
  • Headless test (button click, check box toggle, plot) passing with gfortran 16.2 (release and -fcheck=all), nvfortran 26.9 and fpm.
  • FoBiS modes (tests, examples, static library; gnu and nvfortran) and fpm.toml in sync.
  • figure_hello running in a window on Linux (WSLg), X11 and Wayland.
  • Idle cost of lazy redraw measured and explained (Frame loop); default max_wait kept at 0.5 s.

M2: generated raw layer — done ​

  • scripts/gen_bindings.py generates the bind(C) interfaces and the enumeration parameters from cimgui's and cimplot's metadata (definitions.json, structs_and_enums.json) and classifies every public function as direct, glue or skipped (Raw bindings). Enumeration values are generated, never copied by hand.
  • The output is committed; CI checks it for drift and checks that every bound function is defined in the native library (fobis rule --ex makecoverage).
  • The C++ glue for the functions that pass structs by value (above all the ImPlot items, ImPlotSpec) is generated too, with bind(C) mirror types for the structs, size-checked by figure_test_layout.

M3: images and speed — done ​

  • Textures from contiguous integer(int8) RGBA arrays, uploaded without intermediate copies: done (texture_object, ig_image, ip_image).
  • ImPlot heatmaps from Fortran 2D arrays (column-major aware): done (ip_heatmap, read in place, j = 1 at the bottom; ip_colormap_scale).
  • Plot items generic over real32 and real64, so real32 data is never copied into a real64 temporary: done for ip_line, ip_scatter, ip_bars and ip_shaded, with item styles (ip_spec).
  • Strided series (matrix rows) passed as base address and stride, without the compiler's temporary copy: done for ip_line(label, y, row) with uniform abscissae (ImPlot applies one stride to x and y, so a contiguous x cannot go with a strided row).
  • A Mandelbrot explorer (src/examples/figure_mandelbrot.F90) and a redraw benchmark at 4K (src/examples/figure_bench_texture.F90): about 100 frames/s with a new 3840 x 2160 image every frame (measurements).

M4: platforms and CI — done ​

  • GitHub Actions: ci.yml (Linux, gfortran, coverage, from the FoBiS scaffold) and platforms.yml: macOS (gfortran and Apple clang), Windows (MSYS2 UCRT64 gfortran), Linux with nvfortran. Each builds the native layer, checks the platform's link line against SDL's, builds and runs the headless tests with FoBiS and fpm, and builds the examples.
  • Green on all four (2026-11-04): Linux gfortran (with coverage), Linux nvfortran, macOS 14 arm64, Windows MSYS2 UCRT64; on macOS and Windows the headless and layout tests also pass through fpm, so the generated glue passes and returns structs correctly on those ABIs.
  • Platform link lines in fobos varsets (--varset macos|windows), checked against lib/pkgconfig/sdl3.pc; fpm reads them through scripts/fpm.sh (Other platforms).

M5: remote and web — remote done, WebAssembly to try ​

  • Remote UI: done (Remote UI). app%init_remote serves the interface to a web browser over a built-in WebSocket server; the program needs no display or GPU and stays native (OpenMP, MPI, GPU), e.g. on a cluster node reached through an SSH tunnel. Tested end to end on every CI platform.
  • Experiment, deferred: the whole application compiled to WebAssembly with a patched flang and Emscripten SDL3 (no OpenMP, no MPI there).

Documentation with real pictures — done ​

  • Frame capture with scripted input (FIGURE_CAPTURE, Screenshots and videos); every picture of this site is a recording of the program it describes, made by scripts/docs_media.py.
  • Found by the pictures: a growing history ran off its plot; ip_setup_axes(..., auto_fit) refits the axes every frame.
  • The brand: the seal mark (a window and its plot drafted with a brush, signed with a vermilion seal carved with F), the site's palette, and app%set_style with seal as FIGURE's default style.

v0.1.0 — released 2026-11-05 ​

The scope of the first release, step by step in issue #1:

  • Licence: MIT; the third-party notices: done.
  • Docking: the docking branch of Dear ImGui; windows dock into one another as tabs and splits, and programs set layouts (Docking): done.
  • Themes, fully customisable (Styles): done.
    • every colour and size of Dear ImGui and ImPlot from Fortran;
    • themes as files, embedded, with a curated set (seal, seal-light, paper, high-contrast, colour-blind-safe line colours);
    • load_style and save_style;
    • fonts, with a bundled default;
    • window flags and scoped style changes;
    • a recorded theme gallery.
  • Testing: a public testing module for synthetic input (Headless testing): done.
  • Performance: the cost of continuous redraw measured locally and in remote mode (scripts/measure_redraw.py); remote frames skipped when unchanged, capped at 60 per second with one frame at most queued, sent with 12-byte vertices and deflated when the link is the bottleneck; the Performance guide: done.
  • Remote security: an access token in the URL, random by default (Remote UI): done.
  • fpm: FIGURE usable as a dependency of other fpm projects: a self-contained package (fpm compiles the native layer itself, SDL3 from the system), published for each release as the tag vX.Y.Z-fpm (FIGURE as an fpm dependency): done, first published with v0.1.0.
  • Documentation: every page checked against the code, every recording regenerated, the changelog, the README: done.
  • Release v0.1.0: the tag, the GitHub release, the v0.1.0-fpm package: done.

v0.2.0 — released 2026-11-06 ​

Driven by a first application outside the repository, tools for a CFD solver: a live checker of its log files and editors of its input files.

  • Log axes for residual histories (ip_setup_axes(..., xlog, ylog)): done.
  • Form widgets (Widgets): text fields bound to character variables, integer fields, drop-down lists, tooltips, field widths, collapsing headers, tabs, tables, id scopes, disabled blocks: done.
  • Lists and regions (Widgets): selectable lines, wrapped, disabled and coloured text, child regions that scroll on their own: done.
  • Menus and shortcuts (Menus and shortcuts): menu bars, menus, items, key chords (cmd on macOS, also in the browser): done.
  • Testing: test_click and test_drag let the pointer rest on the item before pressing, as a user does: done.
  • Popups and modals, a confirmation before quitting (Menus, popups and shortcuts): done.
  • File dialogs (File dialogs): the system's own, asynchronous, window mode: done.
  • Plots for live checks (Plots, Docking): tick label formats, subplots with linked axes, docking a window that appears later: done.
  • Found by the tools (issue #2): figure_testing in the static library; the window's title after init (app%set_title); a font size changed at run time reaching the next frame; file dialogs starting from the program's working directory: done.
  • Pictures and layouts: a rectangle of the window saved as a PNG (app%save_image, Save an image); the windows' arrangement saved and loaded at run time (app%save_layout, app%load_layout, Docking): done.
  • The tools (Showcase): a run checker following a run's history files (a navigator for hundreds of them, comparison, saved plots and layouts), the editors of the solver's and the grid tool's input files: done.
  • Workspaces and long lists: a bar along a side of the window (ig_begin_side_bar, Docking), Lucide icons in every font (ICON_*, Icons), workspace buttons with an icon above the label (ig_tool_button), bringing a window forward (ig_focus_window), text level with fields (ig_align_text_to_frame_padding), the size of a text (ig_text_size), long lists drawn row by row in view only (list_clipper_object, Widgets): done.
  • Release v0.2.0: the tag, the GitHub release, the v0.2.0-fpm package: done.

v0.3.0 — released 2026-11-08 ​

The next application is one GUI for a case of the Xall solver, from the mesh to post-processing; the plan is issue #3.

  • Looks and palettes (Styles): a style split into a look (the geometry: seal, fusion, adwaita, fluent) and a palette (the colours, derived from twelve roles and checked for contrast: FIGURE's four, Nord, Solarized, Gruvbox, Dracula, Catppuccin, Tokyo Night, One Dark), chosen separately with app%set_style(look=, palette=); palette='auto' following the system's light or dark setting; the roles for the program's own messages (app%palette_color); theme files with look, palette and [palette]: done.
  • The window's frame drawn by FIGURE; the window's icon (Frame loop): decorations='figure', a borderless window with a title bar drawn by FIGURE in the palette's colours, the main menu bar inside it, the buttons on the right (left on macOS), the system's hit test answered from the last frame, double-click to maximize, close through the quit path; app%set_icon from an image or an ICON_*: done.
  • Trees (Widgets): ig_tree_node with a click on the label told apart from the arrow (clicked), leaves, selection, the full width; ig_tree_pop; ig_set_next_item_open; trees in a table's first column with values in the others; the children of a large node clipped: done.
  • Processes and a log view (Processes and tasks): process_object, programs started without a shell, captured (the output drained by a native thread that wakes the frame loop, the child killed when the program ends) or detached (the output to a file, the child outliving the program); log_view_object, a ring buffer of lines drawn row by row in view, following the end, lines chosen and copied: done.
  • Background tasks (Processes and tasks): task_object, a Fortran module procedure run on a native thread with its own copy of the data, progress and its message posted to the frame loop, cooperative cancel, failures reported, the result moved back without a copy; the threading rule enforced at FIGURE's drawing entry points (FIG_ERR_STATE): done.
  • Feedback (Progress bars, Notifications): ig_progress_bar, determinate or indeterminate; app%notify, notifications drawn by FIGURE in the palette's roles with an icon per kind, stacked, fading at the end of their time, dismissed by a click, the last 100 kept (app%notifications); the status bar as a recipe on the bottom side bar: done.
  • A file browser drawn by FIGURE (File dialogs): app%open_file_browser and app%save_file_browser, answered through app%file_dialog_result as the system's dialogs, the same in window, remote and headless modes: folders first with sizes and dates, sorting, filters, hidden files on request, a path field with Tab completion, the parent, places (home, working directory, roots, recent folders kept between runs in FIGURE's settings file), a new folder, a question before a save replaces a file, errors shown in the browser: done.
  • Multi-line text and a monospace font (Multi-line text, Fonts): text_buffer_object, text of any length kept by the native layer and grown while the user types or pastes, CRLF read as LF; ig_input_text_multiline, editable or read-only, Tab as a character on request, Dear ImGui's undo and redo kept; IBM Plex Mono bundled as 'plex-mono', the Lucide icons merged into it: done.
  • Drag and drop, the clipboard (Drops, Clipboard): app%dropped, the files and folders dropped on the window, reported once with the point of the drop, so that a program tells which pane received them; test_drop for tests; ig_set_clipboard and ig_get_clipboard, on the system's clipboard in a window, the program's own in headless mode, and in remote mode the program's own joined to the browser's (a copy written to it where the browser allows it, a paste read from it): done.
  • A one-line installer (Installation): install.sh --gnu|--nvidia|--fc, the missing packages printed (--deps runs them), installs per compiler with a pkg-config file and a manifest, --uninstall: done.
  • The windowed path verified in CI; Intel ifx (Installation): the Platforms workflow runs figure_hello in a real window on macOS, Windows (Mesa's software OpenGL) and Linux (Xvfb), with the system's frame and with decorations='figure', and checks the captured frames (scripts/window_check.py: the size, not blank, known widgets' pixels; the frames kept as artifacts); FoBiS modes tests-ifx, examples-ifx, figure-static-ifx and an ifx job with the fpm test and the fpm dependency: done.
  • A colormap registry and scientific colormaps (Colormaps): ip_colormap by name, reversed (<name>_r) and in discrete bands (levels); bundled cividis, inferno, magma, turbo, cmocean's thermal, haline, deep, balance and curl, ParaView's Cool to Warm, Crameri's batlow, vik, roma and romaO, each after a licence check; ip_load_colormap from a CSV table or a ParaView JSON preset; Viridis the default of heatmaps: done.
  • ImPlot extras and contour lines (Plots): ip_error_bars, symmetric or not; ip_annotation; drag lines and points (ip_drag_line_x, ip_drag_line_y, ip_drag_point) updating the program's variables in place; ip_contour, contour lines computed in Fortran (marching squares, saddles resolved by the cell's centre value, NaNs leaving holes), levels given or at round numbers (ip_contour_levels), coloured from a colormap or in one colour, labelled on request; ip_contour_lines for the segments alone: done.
  • Colour editing and a colour-scale legend (Colour editing, Colormaps): ig_color_edit, a colour editor with a picker bound to real(real64) RGB or RGBA; ip_colormap_legend, a legend of a colormap, vertical or horizontal, continuous or with discrete levels as bands, as an item of any window: done.
  • The 3-D view (3-D views): view3d_object, meshes of triangles, quads, structured surfaces and lines read in place from the program's arrays, coloured per vertex or per cell through the colormaps, a camera (orbit, pan, zoom, fit, the six standard views) driven by the mouse or the program, picking of the element under a pixel, hovered or clicked, up to six clipping planes; drawn by a software rasterizer, the same pixels in window, remote and headless modes, rendered only when something changed, at half resolution while the camera moves, on up to 4 threads: done. The design is settled for v0.3.0 (why): the software rasterizer (A) in every mode; GPU rendering in a window (B) only when an application draws more than about 10⁶ triangles in a window, behind a check of the OpenGL renderer; no WebGL renderer in the browser (C).
  • Changing images in remote mode (Changing images): a texture updated in consecutive frames, the 3-D view while the camera moves, goes as JPEG (stb_image_write, bundled), then exact once it is still; init_remote(lossy=.false.) keeps every image exact. A moving 1600x1000 view: from 91 MB/s raw to 0.8 to 7 MB/s: done.

v0.3.1 — released 2026-11-09 ​

A patch of three defects of v0.3.0, tracked in issue #5:

  • quit and request_frames safe from a task; app%wake: the flags a task may set or read are atomic, a request from another thread wakes a lazy loop at once, and app%wake() starts the next frame from any thread (Waking the loop): done.
  • printf formats checked against the value's kind: every format FIGURE passes to Dear ImGui or ImPlot is checked first, a bad one refused with FIG_ERR_ARGUMENT (Formats): done.
  • The 3-D view owns the mouse wheel while hovered: inside a scrolling window or child, the wheel over the view zooms it and no longer scrolls the container (Mouse): done.

v0.4.0 — released 2026-11-10 ​

Widget control, errors a Fortran programmer can act on, and the plots a monitor and a post-processor need; the plan, step by step, is issue #6:

  • Usage errors reported, not aborted: a record of the frame's scopes checks every begin/end and push/pop pair before Dear ImGui sees it; a wrong end, a scope left open and a widget with no frame open are reported by next_frame with messages naming the Fortran calls, in three modes (app%set_checks: 'abort', 'report', the new default, 'recover') (Pairing and frames): done.
  • Shortcuts routed to the focused window: ig_shortcut(keys [, scope] [, repeat]) goes through Dear ImGui's routing: 'focused' (the new default) fires only in the window with the focus and not while a text field holds the key, 'global' wherever the focus is, 'item' for the item being edited; ig_set_next_item_shortcut gives a chord to a button (Shortcuts): done.
  • What happened to an item: ig_last_item() returns an item_status_object, a snapshot of the item drawn last (hovered, active, focused, visible, activated, edited, deactivated, deactivated_after_edit, toggled open, clicked and double-clicked per button, its rectangle), filled by one native call; ig_item_hovered([delay]), ig_any_item_hovered, ig_any_item_active; ig_combo reports its pick as an edit (What happened to an item): done.
  • Scrolling and keyboard focus: ig_scroll_here([ratio]) after an item, ig_scroll_to_pos(pos [, ratio]) for a row a list clipper does not draw (clip%item_height, new, gives the rows' distance), ig_get_scroll, ig_set_scroll; ig_focus_here([offset]) gives the next field the keys, ig_default_focus the item a modal starts from; the log view follows its end through ig_scroll_here (Scrolling and focus): done.
  • Layout in em: ig_font_size, ig_em(x), ig_line_height([spacing]), ig_frame_height([spacing]), ig_available; ig_spacing, ig_dummy, ig_new_line, ig_indent, ig_unindent, ig_separator_text; ig_begin_group/ig_end_group; ig_align_begin(id, where)/ig_align_end (a group centred or right-aligned, its width from the previous frame, one more frame asked when it changes) and ig_align_next(width, where); ig_push_item_width/ig_pop_item_width; the three new pairs in the scope record (Layout): done.
  • Context menus and tooltips with content: ig_begin_popup_context(id [, on] [, button]) opens a menu on a right click over an item, a window's empty space or the background; ig_begin_tooltip/ig_begin_item_tooltip with ig_end_tooltip hold any content (a table, a plot); ig_text_link, and ig_text_link_url, which opens a URL in the browser (in remote mode through the page; headless, test_opened_url reads it); the new pairs in the scope record (Context menus, Tooltips): done.
  • Tables: frozen header, sorting, row colours, trees in tables: ig_begin_table freezes rows and columns in view (freeze_rows, freeze_cols) and takes sortable, hideable, reorderable, scroll_x; ig_table_setup_column a stretch weight and how a column sorts and hides; ig_table_sort reports the order the user asks (the program sorts a permutation of its rows); ig_table_row_color, ig_table_hovered_column, ig_table_column_enabled; ig_tree_node(..., span_all_columns); every ImGuiTableFlags_* exported (Tables): done.
  • Numbers and choices: ig_input, ig_drag and ig_slider for int32, int64, real32 and real64, scalar or vector, with checked formats (an int64's written as an int32's), scale='log' and clamp; ig_input's enter_returns and read_only; ig_slider_angle (radians shown in degrees), ig_drag_range; ig_radio and ig_list_box (clipped, a height in pixels) (Numbers, Choices): done.
  • A canvas and drawing primitives: ig_canvas(id, width, height, ev [, texture]) places an area that takes the mouse and owns the wheel while hovered; its canvas_event_object gives hovered, active, clicks, double clicks, presses and releases per button, the pointer in canvas pixels, the drag, the wheel and the modifiers; ig_draw_line, ig_draw_rect, ig_draw_circle, ig_draw_polyline, ig_draw_polygon, ig_draw_text and ig_draw_image draw on the window, the foreground, the background or inside a plot in plot units; ig_cursor_screen_pos, ig_invisible_button; test_drawn_extent looks on a layer and counts vertices (Canvas): done.
  • Plot data passed in place: the items (ip_line, ip_scatter, ip_bars, ip_shaded, ip_error_bars) take arrays of any stride (runs%cl, q(1, :, k), y(::2)) and give ImPlot their byte stride; an array whose stride differs from the ordinates' is copied at their stride; integer(int32)/integer(int64) abscissae, converted; test_plot_copies, test_plot_stride. What a compiler copies before the call is measured and documented (Data in place): done.
  • Plot axes: ip_setup_axis sets up any of the six axes (X1-X3, Y1-Y3) with a label, a scale ('linear', 'log', 'symlog', 'time'), a checked format, its side, direction, lock and grid; ip_set_axes sends the next items to them, each fitting its own data; ip_setup_axis_limits, ip_setup_axis_ticks (fixed ticks and labels), ip_setup_axis_constraints (bounds of pan and zoom), ip_setup_legend (compass point, outside, in a row); ip_plot_limits and test_plot_tick of any axis; ip_setup_axes' xscale/yscale (xlog/ylog kept, deprecated); setup calls out of place are usage errors, not ImPlot's assertions (Axes): done.
  • Plot interaction: ip_plot_hovered, ip_plot_mouse, ip_plot_to_pixels, ip_pixels_to_plot (on any axis pair), ip_plot_selection and ip_cancel_selection (the right-button box, kept without the zoom); ip_drag_rect, ip_tag (a value on an axis, by default in the last item's colour), ip_inf_lines (at real or integer positions), ip_text; the items ip_stairs, ip_stems, ip_histogram and ip_histogram2d (NaNs left out, binning rules counted by FIGURE); calls outside a plot, the drag tools included, are usage errors (Reading a plot, Marks in a plot, Histograms): done.
  • A field through a colormap in one call: ip_field_image(label, f, x0, x1, y0, y1 ...) colours a real32 or real64 field into a texture kept between frames, on a 'linear', 'log' or 'symlog' scale with a NaN colour (values <= 0 on log masked to it), and colours it again only when changed or its range, colormap, scale or array change; log and symlog through a table indexed by the values' bits, restricted to the range (5 to 9 times faster, within 1/255); ip_colormap_legend's scale, and ip_colormap_legend_edit, the legend whose range the user drags and zooms; test_field_uploads, test_field_textures, test_field_time, test_field_pixel (Fields): done.
  • A player for snapshots: ig_player(id, player [, labels]) with a player_object (index, count, playing, speed in snapshots per second, mode 'once', 'loop' or 'bounce'): previous, play/pause, next, a slider showing each snapshot's label, a right-click menu for the speed and the mode; it plays on the frame clock (1/60 s per headless frame) and asks for frames while playing, so lazy redraw keeps time (Players): done.
  • The documentation, complete and checked: scripts/check_docs.py fails on a public entity, a public component or a dummy argument without a !< doc comment, a feature-map row whose section has no compiled example (and, for the rows marked visual, no picture or video), and a hand-written Fortran block; --names checks the name map and --media a page's media (under 5 MB); CI runs them with the examples' build. The name map, generated by scripts/gen_names.py: every Dear ImGui and ImPlot function, linked to its header line at the vendored commit, with the FIGURE call that reaches it, or "raw only". The recorder draws the pointer in videos and, with #! keys, captions each key chord (Screenshots and videos); the v0.4.0 videos recorded again with them. Tutorial part three, chapters 18 to 22: the solver studio grows the v0.4.0 features, each chapter a compiled program tested headless by the documentation's build and recorded. A fresh reader's pass over the installation and part one; the migration notes: done.
  • A fallback font for symbols Plex lacks (S10): moved to v0.5.0.

v0.5.0 — released 2026-11-11 ​

Pictures without a GPU, tests that find items by path, an application layer, images from files and four extensions (a code editor, gizmos for the 3-D view, ImPlot3D, Markdown); carried over from v0.4.0: the fallback font (Noto Sans Math), an unrouted shortcut scope, plot data in place under nvfortran and a monotonic clock. The plan, step by step, is issue #7.

  • Pixels without a GPU (S1): FIGURE's own CPU renderer of Dear ImGui's draw data (native/figure_swrast.cpp, the owner's choice from the spike against Mesa's llvmpipe): what the OpenGL 3 backend asks of a GPU (scissors, textures with their filter, vertex colours, blending into 8 bits), the image's top-left tie rule, 8 threads by bands of rows. app%save_image and FIGURE_CAPTURE* work in headless and remote modes, and FIGURE_CAPTURE_HEADLESS=1 records a window program without a window (Screenshots and videos). test_capture and test_compare_image check a window against a golden (per channel |Δ| ≤ 2, no pixel more, masks), writing .new.png and .diff.png on a mismatch (Pictures as tests). The native layer is compiled with -ffp-contract=off. Headless mode keeps CPU copies of user textures, gives the font atlas ids of its own and registers the sampler callbacks. Against an RTX 4070 the renderer agrees within 2 levels on 68 of the 80 documentation recordings; 3 differ by one pixel of a plot line, 9 draw what a task or a process produced by the wall clock. A 1400 x 860 frame takes 0.7 to 1.7 ms on 8 threads. scripts/docs_media.py --check compares each poster with the CPU renderer's and --update accepts the new ones (in CI since S9): done.
  • Shortcuts: an unrouted scope 'always' (S11): ig_shortcut(keys, scope='always') is Dear ImGui's IsKeyChordPressed, v0.3's behaviour: every call of the chord fires, whatever has the focus, a text field being edited included; ig_set_next_item_shortcut refuses it. The four scopes in one table, and v0.4.0's migration note corrected: v0.3's behaviour is 'always', not 'global' (Shortcuts): done.
  • A monotonic clock (S13): figure_time() → real(real64), seconds since its first call on the system's monotonic clock (CLOCK_MONOTONIC on Linux: SDL's CLOCK_MONOTONIC_RAW runs 7 to 11 % fast on WSL2), never stepped by the system (nvfortran's system_clock is the wall clock, which WSL2 steps); callable before init*, after destroy and from any thread, a task included. FIGURE's tests time with it, in place of their own clock and of system_clock (Time): done.
  • A fallback font for symbols Plex lacks (S10): Noto Sans Math 3.000 (OFL-1.1), vendored with its licence, merged into every text font after Plex and Lucide and scaled to the text font's em: the Greek letters and ∇ in Plex Mono, ∇ in Plex Sans (the glyphs CFD writes checked one by one with fontTools: Noto Sans Math lacks only · and the super- and subscript digits, which both Plex fonts have, so STIX Two Math is not needed). app%add_fallback_font(file [, stat]) for a program's own, after the bundled one; test_glyph tells which font draws a character (The fallback fonts): done.
  • Plot data in place under nvfortran (S12): the 1-D items' array dummies are asynchronous, and nvfortran 26.9 then passes rows, strided and reversed sections in place, as gfortran and ifx do (C descriptors, the plan, were measured and dropped: nvfortran copies before it builds one). A reversed section is copied by FIGURE as fast as nvfortran copied it: into scratch arrays kept between calls, through a contiguous view of its memory. A component of an array of derived types stays a compiler copy on gfortran and nvfortran (a documented limit). figure_test_plot_data holds what each compiler passes in place (Data in place): done.
  • Images from files (S4): fig_read_image(path, rgba [, stat]) decodes a PNG or a JPEG into integer(int8), allocatable :: rgba(:,:,:), rgba(4, width, height) with row 1 the file's top row, the layout of tex%update; it draws nothing, so a task may call it (asynchronous loading is a task: no new mechanism). tex%load(path [, smooth] [, stat]) reads a file into a texture on the main thread. stb_image 2.30 (MIT or public domain), vendored beside stb_image_write at the same commit, with its PNG and JPEG decoders only and no file or URL access of its own; a missing file, a file of another format and a damaged one are refused with their messages. FIGURE's failure message is now kept per thread, so a task's failure no longer overwrites the main thread's (Reading images): done. S1's picture comparisons will decode PNGs with it.
  • Tests: items by path, a frame driver, id and label checks (S2): Dear ImGui's own item hooks (IMGUI_ENABLE_TEST_ENGINE, implemented by FIGURE: no imgui_test_engine code) fill a table of each frame's items: role, label, id, window, rectangle, state (checkable, checked, openable, opened, takes text) and the text it shows, shaped as an accessibility tree. test_item_exists, test_item_rect, test_item_click, test_item_type_text, test_item_checked, test_item_value and test_menu_click take a path (Window/Label, //Window, ##id, *, $$n, as the test engine's references); a missing path names the nearest item; a menu path opens its submenus over the next frames. test_run(max_frames) draws frames until no input is queued and no frame is asked for. test_id_conflicts finds the ids two items share without the pointer over them, test_unnamed_items the icon-only buttons without a tooltip. Recording is on in headless mode, and costs 0.02 µs per item and frame (Finding items by path): done.
  • An application layer (S3): a window registry (app%add_window, window_visible, set_window_visible), its View menu (app%view_menu: the windows, the layouts, Reset layout) and its close buttons; named layouts of the dock space (add_layout, switch_layout, reset_layout), built by the program when ig_dock_layout_begin is true for the current one (app%layout(): no callback), each keeping the arrangement the user leaves it in; preferences in one text file per program (open_prefs, save_pref, load_pref of texts, integers, reals and logicals), with the windows' visibility, the layouts, the style and the window's geometry, written every 30 s when changed and at destroy through a temporary file and a rename (a crash leaves the last save whole); message boxes drawn by FIGURE, any number at once (app%message_box, polled); ig_splitter between two panes; the window's size limits (app%set_size_limits) (Windows and layouts, Preferences, Message boxes, Splitters): done.
  • A code editor (S5): code_editor_object, ImGuiColorTextEdit (the goossens fork, MIT, with dtl, BSD-3) vendored at commit 0a489da with FIGURE's own glue and one patch of one line (the fork's marker list renumbered into a bool). It draws through Dear ImGui only (the same in every mode), in IBM Plex Mono with the fallback symbols and the style's colours. Languages are data (language_object: keywords, types, comments, strings, numbers, case, a key = value mode); code_language ships Fortran, key = value input files, plain text and the fork's thirteen. Marks of three severities with a tint, an icon and a tooltip (mark, mark_of, clear_marks); completion of the program's words, keys of several words included, polled with completing; find, replace in one undo, goto, cursor, selection, insert, word_at_cursor, undo, redo, read_only; draw returns .true. when the user changed the text. code_diff draws two texts' difference by id, in one column or side by side, and code_diff_lines reports the lines added and removed, from a task too (Code editor): done.
  • Gizmos for the 3-D view; a gradient editor (S6): ImGuizmo (MIT) vendored at commit 105e4fd, its subset ViewManipulate, Manipulate and ImGradient, with FIGURE's glue and three small patches (the per-frame state without BeginFrame's window, the cube's turn landing on its target, ImGradient's state per editor). v%view_cube turns the camera to the face, edge or corner clicked and orbits on a drag; v%gizmo(id, matrix [, mode] [, space] [, snap]) moves a 4x4 placement by arrows, rings or handles, polled, for a clipping plane, a box or a probe placed by hand; v%view_matrix and v%projection_matrix give the camera's matrices (column-major, OpenGL's conventions, as ImGuizmo's; real64, ImGuizmo computing in real32 about the camera's target). ig_gradient_edit edits any continuous colormap by its stops, resampling it and its registered variants, fields and 3-D views coloured again; ip_colormap_stops gives them, to save as a CSV (Gizmos, Editing a colormap): done.
  • ImPlot3D: small 3-D figures (S7): ImPlot3D (MIT) vendored at commit c54525f (the submodule of cimplot3d v0.5) with one patch (no FPE without a mouse position), its C API and metadata from cimplot3d v0.5 (MIT), fetched as cimgui and cimplot are; scripts/gen_bindings.py generates figure_cimplot3d and figure_cimplot3d_enums from that metadata, and the name map covers ImPlot3D. ip3_begin_plot, ip3_end_plot, ip3_setup_axes (labels, initial ranges and rotation), ip3_line, ip3_scatter, ip3_surface (over a rectilinear grid or any grid of quadrilaterals), ip3_mesh, ip3_text and ip3_spec; the items take the 2-D items' strided interface (any stride read in place, ASYNCHRONOUS dummies), and a surface takes FIGURE's colormaps, copied into ImPlot3D's registry and followed through ig_gradient_edit's edits. It draws through Dear ImGui only: the same in every mode (3-D plots): done.
  • The examples' runs are tests: docs/examples/build.sh fails when a run exits with a status other than the one its marker states (0 for !run, STATUS for !run-exit STATUS, an example that demonstrates an error exit), so a failed self-test no longer reaches the pages as [exit status N]. The tutorial's checks after a second run wait for its field to be read, as after the first: the Result panel comes forward when the reading task ends, which under load landed between a click and its check (Contributing): done.
  • Markdown in the window (S8): imgui_rich_md (MIT, the owner's choice) vendored at commit 427bcb1, its renderer, search and documents only, with md4c (MIT, its parser) at the commit it pins, 481fbfb, FIGURE's glue and one patch of one line (its images decoded by FIGURE's stb_image). No LaTeX, no images from URLs, no Mermaid. ig_markdown(text [, link]) draws a text at the cursor and markdown_view_object a document (init, set_text, load, draw) with a table of contents and a find bar (find, matches, current_match, scroll_to). Text in IBM Plex Sans, its Bold, Italic and Bold Italic now bundled (OFL-1.1, the same release as its Regular), code in IBM Plex Mono, the icons and the fallback fonts merged; headings, lists, tables, quotes and admonitions, code blocks, images from PNG and JPEG files. Links are reported, never opened: .true. on the frame one is clicked, its URL in link (polled); a link to a heading scrolls there. It draws through Dear ImGui only: the same in every mode (Markdown): done.
  • The documentation pass: every picture from one renderer, checked (S9): every recording of the site recorded again in one pass, headless, by S1's CPU renderer (docs_media.py --headless), the GPU's and llvmpipe's posters of earlier releases and the stale seal pictures of v0.3.0 replaced, posters chosen again; docs_media.py --check runs in the Checks workflow on every push, its differing pictures kept as an artifact. A capture script's wait holds the recording until the program's tasks and processes are done (fig_tasks_busy, fig_processes_busy), so the recordings of runs and reads by the wall clock (the solver of the tutorial, a task's read) are the same on any machine and under any load (Input scripts); a recording's #! fresh folder is removed before its program starts, so the tutorial's example cases do not depend on the recordings run before; the mandelbrot recording masks its line of timings. The name map covers the extensions: the functions of ImGuiColorTextEdit, ImGuizmo, ImGradient and imgui_rich_md that FIGURE calls reach, by FIGURE call, and the native glue bound outside figure_c_native (the 3-D view, the editor, Markdown) is followed too (Dear ImGui and ImPlot names). Tutorial part three grows by three chapters: the studio's windows registered, a View menu and layouts, its settings kept (23); its input in the code editor with the mistakes marked, its help in Markdown (24); a clip plane placed with a gizmo, a view cube, and a picture test of its main window by paths (25) (Tutorial). A fresh reader's pass on the pages of v0.5.0, and the check modes stated plainly: 'report' without a stat stops the program, 'recover' goes on (The three modes): done.

v0.6.0 — released 2026-11-15 ​

Known defects and risks first: what v0.5.0 left open, the vendored libraries against their upstream heads, and CI running the gate's compilers on every platform, with the documentation's pictures checked there. It had no driving application; what xall_figure met in its round-4 work (3-D views on a large grid, floating-point traps) came in between. The plan, step by step, is issue #10.

  • The macOS "early wake" (S1): figure_test_tasks let up to 3 frames start before a task's app%wake, seen on the macOS runner. FIGURE_DEBUG_WAKE logs each wake-up sent and what ended each wait of the loop (What ended a wait); its logs showed no early wake-up: the frames were owed to earlier input, and the test's settling took a slow frame (0.07–0.15 s there) for a wait. The test settles by test_run now and allows no early frame, 10 runs a push on macOS and Windows: done.
  • Dear ImGui's 0 / 0 in a SizingStretchProp table (S2): FIGURE's first patch to fetched code (native/patches/, applied by CMake and to the fpm package, a canary when upstream's line moves); a program built with -ffpe-trap=invalid no longer stops at such a table, and Markdown no longer holds the traps (ocornut/imgui#8718): done.
  • Compiler canaries (S5): figure_test_canaries passes while a compiler defect FIGURE works around is still there and fails, naming the workaround to remove, once it is gone (Known issues): done.
  • v0.5.0's choices reviewed (S6): items for finding by path are recorded in every mode from the first frame (Finding items by path): done.
  • Dear ImGui at the docking head (S7): 1.93.1 WIP (cf53467); cimgui has no tag there, so FIGURE runs cimgui's generator (scripts/gen_cimgui.sh) and vendors the result in third_party/cimgui. Upstream's new look (stroked arrows, darker backgrounds) is adopted, and 81 of the 94 pictures were recorded again: done.
  • md4c and the code editor (S8): md4c at release-0.5.3, the editor at its fork's head with FIGURE's two patches; SDL stays at release-3.4.20, the newest: done.
  • CI runs the gate's compilers; the pictures checked on every platform (S10): Linux's jobs in the toolchain image (gfortran 16.2), macOS on gfortran 16, fpm v0.13.0 (v0.12.0 on macOS); every picture compared on Linux, macOS and Windows with per-platform masks, tolerances and skips, each with its measured number (Pictures without a GPU); a windowed run with floating-point traps on Windows: done.
  • The name map follows FIGURE's native glue (S12), and tells what FIGURE uses internally (Dear ImGui names): done.
  • From xall_figure's round 4: a program built with floating-point traps opens its window (the native layer holds the floating-point environment around the driver); a fresh code editor's first frames are finite under traps; 3-D views share their render out by blocks of rows among up to 16 threads, leave the grid lines out while the camera moves and free their vertex caches at rest (3-D views): done.
  • The documentation pass (S17): the migration notes, this section, the known issues dated: done.

v0.7.0 — released 2026-11-16 ​

The plan is #12: the steps v0.6.0 moved (2026-11-14), the findings of v0.6.0, and the features no application had asked for, which the owner took in without waiting for one (2026-11-16).

  • Consumers (S1): an installed CMake package, find_package(figure) and the imported target figure::figure, one per compiler (From CMake); the installer builds with Intel ifx (--intel); a sources archive per release, figure-<version>-sources.tar.gz, with every source the native build fetches, built in CI with the network cut (Building without network): done.
  • Portable example cases (S2): a small file API, figure_make_folder, figure_remove, figure_set_file_time, figure_file_time, figure_file_exists (Files and folders); the studio tutorials write their cases with it, and their pictures are checked on Windows too: done.
  • tut13_field's macOS glyph (S3): a picture that fails keeps the font atlas it was drawn with (FIGURE_CAPTURE_ATLAS, Variables), so the next variation on macOS brings its evidence: done; the cause waits for that evidence.
  • Compiler oddities reduced (S4): nvfortran's select case on a deferred-length function result and its internal error on a local named size, each in a few lines with a canary (Known issues); two older findings could not be reduced (their code is gone). Posted on #4; filing is the owner's: done.
  • Upstream drafts (S5): ImPlot's defects (#8), the patches to ImGuizmo and ImPlot3D (#9) and Dear ImGui's 0 / 0 (#11) reproduced on the libraries' heads without FIGURE, each with its draft; filing is the owner's: done.
  • The showcase's pictures from FIGURE's renderer (S6): six of the eight copied again from xall_figure, which now records headless (Showcase); the two that race the wall clock remain a GPU's (Next): done.
  • Drag and drop (S7): ig_drag_source, ig_drop_target, ig_dragging, ip_drop_target (Drag and drop, A plot as a drop target): done.
  • Plots across plots (S8): linked axes by group name, aligned plots, the legend's hover and popup, hidden items, digital signals and grouped bars (Plots across plots, Grouped bars and digital signals). ImPlot's digital bars drew nothing with Dear ImGui 1.93; FIGURE patches the one line until ImPlot changes it: done.
  • Multi-selection (S9): selection_object, ig_begin_multi_select, ig_end_multi_select, index= on ig_selectable and ig_tree_node, the clipper's keep (Selecting many items): done.
  • ImPlot3D's remaining items (S10): triangles, quads, images in the box, one axis's scale, the box's proportions and view, the legend's place, the pointer's ray (3-D plots); no depth buffer until brenocq/implot3d#151 merges: done.
  • The documentation pass (S11): the migration notes, this section, the pages above read afresh; the new pictures measured on Linux, macOS and Windows, all equal there (run 43868894311): done.
  • Found after block D: on macOS a multi-selection's ctrl+click is cmd+click (the tests press the platform's shortcut); a detached process was never seen ended where the first process of a container does not reap it (GitHub's job containers, Docker without --init): FIGURE reaps it, or reads it as a zombie (Known issues), and the examples' runs stop after 10 minutes: done.

v0.8.0 — released 2026-11-19 ​

The plan is #13; the documentation pass is #14.

  • S1, a log axis on a plot that starts empty: not reproduced. Every log axis fits its line from the frame it arrives; a line with no positive value leaves the empty range, as it should. A test keeps it so (Axes).
  • S2, the clipper's keep: a test that fails without it. Dear ImGui forgets a range source that is not drawn, and the clipper draws the focused line anyway, so keep matters when the source and the focus differ (Clipped lists).
  • S3, the showcase: the solvers run from the window recorded headless, each run waited for. The run checker on growing files stays a GPU recording, deferred (Planned, deferred, not planned).
  • S4: find_package(figure 0.7); the changelog's entries keep the case of a name written in lower case.
  • S5, the colour picker: ig_color_picker, drawn in place, with a hue bar or a hue wheel (Colour editing).
  • S6, plots: pie charts (ip_pie_chart), bubbles (ip_bubbles), error bars along x (horizontal) (Pies and bubbles). Custom scales and tick formatters stay out: they are callbacks.
  • S7, ImPlot3D: colours and sizes per point, the axes' formats and ticks, its style by name (3-D plots).
  • S8, upstream: FIGURE's patches stay until the owner's reports (#4, #8, #9, #11) land.
  • The documentation (#14): a chapter on building and running the studio, the tutorial as a build-along, the install page in one order, the reference pages completed and ordered for a learner, the cookbook regrouped, the known issues as a table, and check_docs.py keeping all of it checked.

Released under the MIT licence.