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
| Item | Status | Why, or until when |
|---|---|---|
| The items of Next | planned | v0.8.0: #13, #14 |
| The functions listed "raw only" in Dear ImGui names wrapped | deferred | Until an application asks |
| The whole application compiled to WebAssembly | deferred | An experiment: a patched flang and Emscripten SDL3, no OpenMP and no MPI there |
| The 3-D view rendered on the GPU in a window | deferred | Until an application draws more than about 10⁶ triangles in a window (why) |
| A depth buffer in ImPlot3D's plots | deferred | Until brenocq/implot3d#151 merges (Known issues) |
| The showcase's run checker recorded headless | deferred | After 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 window | deferred | Until 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 browser | not planned | A third renderer, and no pixels on the program's side for tests and captures (why) |
| Dear ImGui's context thread-local | not planned | A crash in place of a race, not a refusal (Known issues) |
| Callbacks into Fortran: custom axis scales and tick formatters | not planned | FIGURE calls no Fortran from C; formats, ticks and fixed scales cover them as data (Plots) |
| The raw bindings called by applications | not planned | The 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.aandlibSDL3.a. - Fortran:
figure_app(loop, lazy redraw),figure_imgui(windows, button, check box, sliders forint32,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.tomlin sync. figure_hellorunning in a window on Linux (WSLg), X11 and Wayland.- Idle cost of lazy redraw measured and explained (Frame loop); default
max_waitkept at 0.5 s.
M2: generated raw layer — done
scripts/gen_bindings.pygenerates thebind(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, withbind(C)mirror types for the structs, size-checked byfigure_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
real32andreal64, soreal32data is never copied into areal64temporary: done forip_line,ip_scatter,ip_barsandip_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) andplatforms.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 againstlib/pkgconfig/sdl3.pc; fpm reads them throughscripts/fpm.sh(Other platforms).
M5: remote and web — remote done, WebAssembly to try
- Remote UI: done (Remote UI).
app%init_remoteserves 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 byscripts/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_stylewithsealas 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_styleandsave_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-fpmpackage: 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
charactervariables, 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_clickandtest_draglet 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_testingin the static library; the window's title afterinit(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-fpmpackage: 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 withapp%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 withlook,paletteand[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_iconfrom an image or anICON_*: done. - Trees (Widgets):
ig_tree_nodewith 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_browserandapp%save_file_browser, answered throughapp%file_dialog_resultas 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_dropfor tests;ig_set_clipboardandig_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 (--depsruns 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_helloin a real window on macOS, Windows (Mesa's software OpenGL) and Linux (Xvfb), with the system's frame and withdecorations='figure', and checks the captured frames (scripts/window_check.py: the size, not blank, known widgets' pixels; the frames kept as artifacts); FoBiS modestests-ifx,examples-ifx,figure-static-ifxand an ifx job with the fpm test and the fpm dependency: done. - A colormap registry and scientific colormaps (Colormaps):
ip_colormapby 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_colormapfrom 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_linesfor the segments alone: done. - Colour editing and a colour-scale legend (Colour editing, Colormaps):
ig_color_edit, a colour editor with a picker bound toreal(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:
quitandrequest_framessafe 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, andapp%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_framewith 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_shortcutgives a chord to a button (Shortcuts): done. - What happened to an item:
ig_last_item()returns anitem_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_comboreports 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_focusthe item a modal starts from; the log view follows its end throughig_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) andig_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_tooltipwithig_end_tooltiphold any content (a table, a plot);ig_text_link, andig_text_link_url, which opens a URL in the browser (in remote mode through the page; headless,test_opened_urlreads it); the new pairs in the scope record (Context menus, Tooltips): done. - Tables: frozen header, sorting, row colours, trees in tables:
ig_begin_tablefreezes rows and columns in view (freeze_rows,freeze_cols) and takessortable,hideable,reorderable,scroll_x;ig_table_setup_columnastretchweight and how a column sorts and hides;ig_table_sortreports 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); everyImGuiTableFlags_*exported (Tables): done. - Numbers and choices:
ig_input,ig_dragandig_sliderforint32,int64,real32andreal64, scalar or vector, with checked formats (anint64's written as anint32's),scale='log'andclamp;ig_input'senter_returnsandread_only;ig_slider_angle(radians shown in degrees),ig_drag_range;ig_radioandig_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; itscanvas_event_objectgives 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_textandig_draw_imagedraw on the window, the foreground, the background or inside a plot in plot units;ig_cursor_screen_pos,ig_invisible_button;test_drawn_extentlooks 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_axissets 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_axessends 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_limitsandtest_plot_tickof any axis;ip_setup_axes'xscale/yscale(xlog/ylogkept, 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_selectionandip_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 itemsip_stairs,ip_stems,ip_histogramandip_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 areal32orreal64field 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 whenchangedor 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'sscale, andip_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 aplayer_object(index,count,playing,speedin 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.pyfails 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;--nameschecks the name map and--mediaa page's media (under 5 MB); CI runs them with the examples' build. The name map, generated byscripts/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_imageandFIGURE_CAPTURE*work in headless and remote modes, andFIGURE_CAPTURE_HEADLESS=1records a window program without a window (Screenshots and videos).test_captureandtest_compare_imagecheck a window against a golden (per channel |Δ| ≤ 2, no pixel more, masks), writing.new.pngand.diff.pngon 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 --checkcompares each poster with the CPU renderer's and--updateaccepts the new ones (in CI since S9): done. - Shortcuts: an unrouted scope
'always'(S11):ig_shortcut(keys, scope='always')is Dear ImGui'sIsKeyChordPressed, v0.3's behaviour: every call of the chord fires, whatever has the focus, a text field being edited included;ig_set_next_item_shortcutrefuses 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_MONOTONICon Linux: SDL'sCLOCK_MONOTONIC_RAWruns 7 to 11 % fast on WSL2), never stepped by the system (nvfortran'ssystem_clockis the wall clock, which WSL2 steps); callable beforeinit*, afterdestroyand from any thread, a task included. FIGURE's tests time with it, in place of their own clock and ofsystem_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_glyphtells 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_dataholds 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 intointeger(int8), allocatable :: rgba(:,:,:),rgba(4, width, height)with row 1 the file's top row, the layout oftex%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_valueandtest_menu_clicktake 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_conflictsfinds the ids two items share without the pointer over them,test_unnamed_itemsthe 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 whenig_dock_layout_beginis 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_prefof 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 atdestroythrough 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_splitterbetween 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 commit0a489dawith FIGURE's own glue and one patch of one line (the fork's marker list renumbered into abool). 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_languageships Fortran,key = valueinput 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 withcompleting;find,replacein one undo,goto,cursor,selection,insert,word_at_cursor,undo,redo,read_only;drawreturns.true.when the user changed the text.code_diffdraws two texts' difference by id, in one column or side by side, andcode_diff_linesreports 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 subsetViewManipulate,ManipulateandImGradient, with FIGURE's glue and three small patches (the per-frame state withoutBeginFrame's window, the cube's turn landing on its target, ImGradient's state per editor).v%view_cubeturns 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_matrixandv%projection_matrixgive the camera's matrices (column-major, OpenGL's conventions, as ImGuizmo's; real64, ImGuizmo computing in real32 about the camera's target).ig_gradient_editedits any continuous colormap by its stops, resampling it and its registered variants, fields and 3-D views coloured again;ip_colormap_stopsgives 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 cimplot3dv0.5) with one patch (no FPE without a mouse position), its C API and metadata from cimplot3dv0.5(MIT), fetched as cimgui and cimplot are;scripts/gen_bindings.pygeneratesfigure_cimplot3dandfigure_cimplot3d_enumsfrom 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_textandip3_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 throughig_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.shfails 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 andmarkdown_view_objecta 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 inlink(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 stalesealpictures of v0.3.0 replaced, posters chosen again;docs_media.py --checkruns in the Checks workflow on every push, its differing pictures kept as an artifact. A capture script'swaitholds 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#! freshfolder 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 outsidefigure_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 astatstops 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_taskslet up to 3 frames start before a task'sapp%wake, seen on the macOS runner.FIGURE_DEBUG_WAKElogs 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 bytest_runnow and allows no early frame, 10 runs a push on macOS and Windows: done. - Dear ImGui's 0 / 0 in a
SizingStretchProptable (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=invalidno longer stops at such a table, and Markdown no longer holds the traps (ocornut/imgui#8718): done. - Compiler canaries (S5):
figure_test_canariespasses 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 inthird_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 targetfigure::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 caseon a deferred-length function result and its internal error on a local namedsize, 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=onig_selectableandig_tree_node, the clipper'skeep(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, sokeepmatters 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.pykeeping all of it checked.