Skip to content

Changelog

1.0.2

  • coordinate core, language-server and lexer runtime floors on 1.0.2 while keeping mkdocs-pseudocode-i18n>=1.0.0,<1.1 as a documentation bootstrap dependency, preventing clean-runner publication cycles;
  • use the documentation Graphviz configuration requested for large examples (outputorder=nodesfirst, node 48 pt, edge 46 pt) while leaving the Thonny runtime renderer unchanged.

1.0.1

  • consume the core 1.0.1 font-aware Graphviz rank spacing, so large shared text sizes keep enough vertical room for nodes and edge labels without Thonny-specific geometry; Mermaid and Tutor semantics remain unchanged.
  • render every MkDocs flowchart example from its localized Pseudocode source through mkdocs-pseudocode-i18n, keeping the documentation renderer aligned with the plug-in runtime.

1.0.0

  • Restored complete multilingual MkDocs Usage documentation for all 14 Pseudocode languages (syntax, OOP, commands, Tutor, flowcharts, language selection and reference).

  • stabilize indentation recovery so one isolated misindented statement produces one diagnostic on the actual offending line instead of cascading errors onto correctly-indented following Si / Sinon Si / Sinon siblings; the coordinated core keeps the first child indentation provisional until sibling evidence confirms the block column.

  • make Graphviz text-size changes visually proportional in both Algorigramme and Tutor by preserving the selected preview scale instead of always fitting the complete SVG back to the same pane width; larger sizes intentionally use scrolling, while Mermaid behavior and the default size 16 remain unchanged.
  • add one persisted, localized flowchart text-size selector (10–40, default 16) shared by Algorigramme and Tutor; changing it rerenders Mermaid/Graphviz through the core/LSP without rebuilding the semantic graph or replaying the cached Tutor session, and Graphviz now uses the visually matched 16 → 14 pt default.
  • keep the localized Refresh label fully visible while restoring the same ↻ refresh icon used by Tutor; ttk sizes the button from the active font and translation, and all 14 MkDocs flowchart guides are verified with language-specific pseudocode plus Mermaid/Graphviz tabs.
  • consume the shared validated-loop-attached-edges-v22 Mermaid geometry: Si / Sinon branches now follow recentered diamonds with safe clearance, while only pathological post-loop voids are compacted; rendering remains identical to VS Code.
  • restore visible Graphviz previews by rasterizing the canonical Graphviz SVG before Tk display; fix Tutor overlay crashes by respecting parsed SVG shape geometry; add a localized Refresh button to the static Flowchart tab; and consume the shared validated-loop-attached-edges-v22 label/vertical-alignment fixes.
  • display the canonical core-rendered Mermaid SVG as the base diagram instead of rebuilding nodes, labels and edges with Tk primitives; VS Code, Thonny and exports now share one geometry and the validated-loop-attached-edges-v22 policy, including vertical main-spine alignment and final-path edge-label placement;
  • consume the core's real post-layout loop normalization: vertical body/continuation spine, smooth WEST-side feedback sweep, EAST exit, and body → test ordering for Répéter … Jusqu’à;
  • rasterize that normalized SVG with mermaidx/resvg using the same bundled font Mermaid measured, and consume the core's render-time comparison workaround so final nodes contain exact < / > glyphs instead of literal entity text;
  • keep Tutor incremental by overlaying active node/edge geometry parsed from that same normalized SVG, including the shared connector segments;
  • remove the duplicated Thonny Mermaid SVG parser and reuse pseudocode_i18n.mermaid_svg directly.

0.9.15

  • consume the corrected core validated-loop-body-subgraphs-v15 Mermaid geometry, whose validated body-only subgraphs keep Pour / Tant Que bodies below their decision and whose nested Repeat/Until subgraphs keep the final condition below the body, while preserving the same Tutor semantic IDs;
  • style the Mermaid/Graphviz engine selectors with a dedicated ttk combobox style derived from Thonny’s current Light/Dark palette and refresh it on theme changes;
  • consume the core 0.9.15 flowchart refinements: question-mark repeat-until decisions, vertically re-centered Mermaid merges, centered/visible Graphviz branch arrowheads and active Graphviz GIF arrowheads;

  • add Mermaid/Graphviz selection to Algorigramme and Tutor, including shared-core SVG/PNG/source/GIF rendering; Thonny now delegates both geometry and semantic Light/Dark palettes to pseudocode-i18n;

  • consume the new core vertical instruction spine and deterministic sequential-edge activation, so loop-body instructions stay one below another and Tutor highlights the outgoing edge whenever the next instruction is guaranteed;

  • remove Thonny-specific flowchart spacing decisions and consume the core-owned canonical Mermaid layout instead; panel-width changes now scale/reuse the same graph geometry, while Pour, Tant que and Répéter … Jusqu'à share the exact topology used by VS Code and other renderers;
  • color Pygments Operator.Word tokens with Thonny’s native keyword tag, fixing localized logical/membership words such as French Non, Dans, Et, Ou and OUEX without imposing theme-specific colors;
  • consume the shared conventional flowchart shapes (io parallelograms, conditional ? labels, localized loop labels and range-loop increment annotations) and the core-normalized SVG geometry; static Algorigramme now receives the same node/edge metadata as Tutor, restoring all labels, while both views share SOUTH continuation, EAST exit and WEST rectangular loop-back ports;
  • preserve shared Tutor node/edge activation, including the feedback edge on the final real loop-body line, so highlighting remains incremental and render-once;
  • coordinate core/LSP/Pygments dependency floors at 0.9.15.

0.9.12

  • color Pygments Operator.Word tokens with Thonny’s native keyword tag, fixing localized logical/membership words such as French Non, Dans, Et, Ou and OUEX without imposing theme-specific colors;
  • consume the shared conventional flowchart shapes (io parallelograms, full localized while labels) and use orthogonal Mermaid step routing so loop-back edges read more clearly;
  • preserve shared Tutor node/edge activation for the new explicit loop taken/exit events, so branch highlighting remains incremental and render-once;
  • automatically select the Diagnostics tab when a .pseudo or .algo editor becomes active, including Thonny’s delayed file-association path;
  • consume the shared per-language documentation source and coordinate core/LSP/Pygments dependency floors at 0.9.12;
  • derive release/dependency checks from package.json.version instead of hard-coded patch versions.

0.9.11

  • fix the published wheel layout so the plug-in is installed under thonnycontrib/pseudocode_i18n instead of being incorrectly flattened to a top-level pseudocode_i18n package by Hatchling's packages option;
  • replace the wheel packages selector with only-include, preserving Thonny's required thonnycontrib namespace and avoiding collisions with the shared pseudocode-i18n core package;
  • add a post-build wheel-layout check to yarn bfc that requires thonnycontrib/pseudocode_i18n and rejects any accidental top-level pseudocode_i18n/ files;
  • keep the 0.9.10 private plug-in-site propagation for the pseudo-lsp child process and keep the shared core, language server and Pygments lexer on >=0.9.9,<0.10; no other ecosystem project needs a release.

0.9.10

  • make the pseudo-lsp child process inherit Thonny's private plug-in site-packages directory through PYTHONPATH, so normal PyPI/Thonny installations can resolve pseudocode-i18n-languageserver, pseudocode-i18n and the shared lexer without development symlinks;
  • preserve any existing PYTHONPATH entries while prioritizing and de-duplicating Thonny's dynamically resolved plug-in site;
  • add a subprocess smoke test that proves a dependency available only from Thonny's private plug-in site is importable by the child Python;
  • keep the shared core, language server and Pygments lexer on the existing >=0.9.9,<0.10 compatibility range; no coordinated release of the other ecosystem projects is required.

0.9.9

  • make diagnostics selectable/copyable in Diagnostics, Tutor Source, Tutor Flowchart and the standalone Flowchart view;
  • consume the stronger shared 0.9.9 multi-diagnostic recovery and explicit localized indentation messages;
  • preserve the shared diagnostic source of truth across all pedagogical panels.

0.9.8

  • add live Documentation search using the core's shared weighted index and render all concrete examples for each card; complete loop constructions remain distinct instead of appearing as duplicate Répéter / Pour entries;
  • open Thonny's native completion popup automatically for Pseudocode typing, with a 90 ms debounce to coalesce rapid keypresses and local exact/prefix/contains filtering so Pour no longer exposes the entire snippet catalogue; Ctrl+Space remains supported;
  • keep snippet data, language resolution and documentation mapping in the core/LSP; the plugin owns only Thonny-specific triggering, filtering presentation and plain-template insertion;
  • render the Diagnostics all-clear message in theme-aware green when there are no errors or warnings;
  • keep static Algorigramme SVG/PNG/Mermaid controls visible but disabled on error-level shared diagnostics, while warnings/information remain non-blocking; render the same boxed, theme-aware diagnostic cards above valid graphs and instead of structurally unavailable graphs;
  • refine the native read-only Tutor Source with full-line alternating bands, a muted line-number gutter and no editor caret affordance, without embedding Highlight.js or another browser renderer; in Dark mode only, brighten syntax roles that the active Thonny theme actually renders as purple while leaving Light mode untouched;
  • make Information e-mail, repository and documentation entries clickable with native Tk text links;
  • centralize Tutor execution eligibility in the shared language-server model and reuse the already-published diagnostics as a zero-reparse fast path; error-level diagnostics block execution, while warning/information diagnostics remain non-blocking;
  • when Tutor is blocked, replace both Source and Tutor Algorigramme with the same complete clickable diagnostic list, hide all execution/GIF controls and the runtime-state column, and never show an unusable source copy;
  • with only non-blocking diagnostics, show them above the controls/source and above the Tutor Algorigramme while keeping execution available;
  • make the Tutor source unmistakably read-only with a lock label, disabled text, per-line bands and theme-aware separators while preserving navigation/copy behavior;
  • distinguish Error / Warning / Information / future Hint severities with dedicated red/orange/blue/purple accents and ⊗ / ⚠ / ⓘ / 💡 symbols;
  • make Diagnostics the single source of error truth for Tutor/Algorigramme: Tutor is blocked by error-level diagnostics and shows the complete shared list, while Algorigramme still renders when only semantic errors exist and falls back to the same diagnostic set only when the AST is structurally unavailable;
  • remove visible Python exception-class prefixes such as ValueError: from pedagogical panels and keep the underlying diagnostic messages in the detected Pseudocode language;
  • syntax-highlight the Tutor source copy with the same Pygments roles and Thonny syntax-theme tags used by the editor, including while Tutor is blocked by diagnostics;
  • render Tutor boolean/null values with the detected Pseudocode literals and consume localized scope/event display text while leaving the shared typed protocol untouched;
  • display shared localized flowchart symbol labels instead of canonical English function / process metadata in the Algorigramme selector;
  • add explicit download icons, copy/download Mermaid controls, centered Algorigramme content and a localized all-clear Diagnostics message;
  • inherit the shared core Tutor GIF fixed non-responsive Mermaid geometry (useMaxWidth=false), eliminating cumulative down/right active-outline drift without adding any per-frame render;
  • consume context-aware range-loop hover, the step-range snippet and fully localized syntax fallback messages from the shared 0.9.8 core/LSP;
  • make SVG exports portable across standalone SVG viewers by relying on the shared core renderer's native SVG text labels instead of HTML foreignObject labels;
  • add theme-aware SVG/PNG export controls to Algorigramme and GIF export to Tutor; GIF export reuses the already loaded Tutor v2 model in a worker thread and never retraces on click;
  • consume the shared 0.9.8 Faire/Do/... syntax, localized XOR aliases/snippet and French short repeat-until formatter output through pseudo-lsp;
  • harmonize Information with VS Code by showing developer, contact, repository and documentation while preserving Thonny/Python/core/LSP/lexer status details;
  • retain Mermaid layout caching/coalescing and O(Δ) Tutor highlighting from 0.9.7.

0.9.7

  • align the Thonny Light-mode Tutor palette with Mermaid's default theme used by VS Code (lavender nodes, Mermaid purple node borders, shared light text/edge colours), while preserving the existing Dark palette and active-step highlighting;
  • replace the Thonny Tutor's custom graph-layout algorithm with the same Mermaid layout source used by VS Code, eliminating divergent placement bugs such as Fin sharing the top rank with Début;
  • keep the 0.9.7 performance model: Mermaid/Chromium runs only for a new scope, theme or settled pane width; the matching SVG is indexed once in O(V+E), and each Tutor step toggles only changed node/edge overlays in O(Δ) without a Mermaid rerender;
  • coalesce concurrent resize/scope/theme renders and cache completed Mermaid artifacts with a bounded cache; pane width is part of the render key so a real resize cannot be swallowed by a spacing clamp;
  • make the Tutor flowchart responsive to the third-pane width through Mermaid nodeSpacing / rankSpacing, preserve active IDs when the asynchronous render is replaced, and label the execution tab as localized Tutor: …;
  • consume pseudocode-tutor/v2 and reorganize Exécution pas à pas into three parallel columns: Source | État | Algorigramme, while keeping Variables, Pile d’appels and Sortie distinct;
  • expose separate one-step and automatic Play controls, plus Pause and the same adjustable Tutor speed concept as VS Code;
  • draw the Tutor directly from one Mermaid SVG geometry on Tk Canvas, applying nested SVG transforms for decision shapes and sampled Bézier edge paths so normal and active strokes cannot drift apart;
  • update only the previous/current active overlay items rather than rescanning the entire graph on every step;
  • follow Thonny Light/Dark UI theme changes without a new LSP request; a theme change schedules one cached/coalesced Mermaid layout render, never per-step work;
  • make Tutor navigation hover blue in both themes, keep disabled controls visually neutral, and show one-step back as |◀;
  • update source highlighting, progressive output and variable rows incrementally during sequential playback instead of rebuilding complete widgets on every step;
  • consume Tutor output deltas directly during sequential Play and rebuild cumulative output only when the user jumps/backtracks to another step;
  • preserve the LSP/core as the only source of Tutor/flowchart semantics; the plugin remains a thin Thonny UI adapter;
  • require the coordinated 0.9.7 core, LSP and Pygments lexer.

0.9.6

  • include a redundant top-level document uri on custom pseudocode/* requests so Tutor/flowchart remain compatible with the language server parameter normalizer;
  • send textDocument.uri explicitly for Tutor and both static/synchronized flowchart requests, and defensively re-impose the current document URI in the shared session request path;
  • display the shared collection-loop documentation title distinctly (for example French Pour — Dans) from the range-loop entry;
  • harmonize the docked Pseudocode view with VS Code as Diagnostics → Exécution pas à pas → Documentation → Algorigramme → Informations, localized from the IDE UI language;
  • add a Python-Tutor-style Exécution pas à pas frontend that consumes shared pseudocode-tutor/v1 data from pseudo-lsp instead of duplicating an execution engine;
  • show the current source line, first/previous/play/pause/next/last navigation, variables with old → new changes, call stack, output/input state and a synchronized algorigram;
  • route static Algorigramme data through the shared pseudocode/flowchart request and add whole-program/symbol scope selection;
  • coalesce/cache asynchronous PNG renders so rapid stepping renders the latest requested Tutor/flowchart state without unnecessary Chromium work;
  • preserve theme-aware diagram backgrounds and common core-provided preview vocabulary;
  • place yarn zip output in the project parent directory, matching the other ecosystem repositories;
  • require the coordinated 0.9.6 core, LSP and Pygments lexer.

0.9.5

  • automatically select the Diagnostics companion tab when a .pseudo / .algo editor becomes active, without forcing it again on ordinary diagnostic refreshes;
  • use Thonny's native Python-equivalent syntax tags instead of a custom Light/Dark palette;
  • classify function/class definitions and constructors like Python while leaving self / this visually ordinary;
  • add 300 ms live diagnostics with red/orange/blue severity accents and no focus stealing;
  • make the docked view visible by default in Diagnostics → Algorigramme → Documentation → Informations order;
  • prioritize diagnostics on hover and add Ctrl+click → Documentation for language syntax while preserving definition navigation for user symbols;
  • generate Documentation from the core and localize its menu/tab name across all 45 Thonny 5 locales;
  • use Ctrl+Shift+I as the primary Format shortcut and Ctrl+Shift+F as an alternate, with uppercase Tk keysyms required by shifted Latin-letter bindings on Linux; migrate the earlier broken lowercase/Alt defaults automatically;
  • remove the redundant manual Analyze menu item/shortcut because diagnostics are already live and automatic; keep the dedicated root menu correctly capitalized/localized by preventing hidden shortcut commands from pre-creating a lowercase pseudocode menu;
  • fix document synchronization so local edits always emit didChange, clear stale diagnostic marks during debounce, and reject diagnostics from older document versions;
  • render flowchart PNG previews asynchronously with scrollbars;
  • report component versions and LSP state in Informations;
  • show Run as F5 / Ctrl+R in the Pseudocode menu;
  • colour Diagnostics-tab error/warning/information lines red/orange/blue with theme-aware accents;
  • open generated .py / .pseudo files automatically in a new Thonny editor tab after conversion;
  • replace free-form ISO language input with a read-only 14-language drop-down showing language name + ISO 639-1 code, including Python → Pseudocode target selection;
  • automatically recover a crashed/failed language-server transport with bounded backoff and full document resynchronization; keep manual restart only as fallback;
  • disable the Pseudocode root menu and all four Pseudocode companion tabs whenever the active editor is not .pseudo / .algo, while leaving Thonny File → Open untouched;
  • leave Thonny’s native Assistant untouched for Python and keep Pseudocode analysis exclusively in Diagnostics;
  • make Diagnostics Lxx markers clickable links that select the owning editor and jump to the exact diagnostic line/column;
  • harden language-server restart with coalesced restart attempts and transport-generation guards so delayed messages/failures from a replaced pseudo-lsp process cannot corrupt the new session;
  • require the coordinated 0.9.5 core, LSP and Pygments lexer.

0.9.0

  • Add a dedicated localized Pseudocode root menu, independent from the source-language selection, with Conversion, Flowchart and Navigation submenus.
  • Add LSP-backed pointer hover, completion documentation and a dockable pedagogical Pseudocode view.
  • Keep Ctrl+Space snippets/completion and Ctrl+click definition while exposing formatting on Ctrl+Shift+I (plus Ctrl+Shift+F).
  • Add menu actions for Pseudocode ↔ Python conversion and Mermaid/SVG/PNG flowchart generation.

  • Fix Pseudocode syntax coloring by integrating with Thonny 5's native syntax-colorer lifecycle instead of racing the built-in Python colorer.

  • Initial Thonny 5 integration for the pseudocode-i18n ecosystem.

  • .pseudo and .algo recognition from the canonical core extension list.
  • Thin JSON-RPC/LSP stdio client which launches the shared pseudo-lsp server.
  • Full-document synchronization with safe handling of Thonny's Open, Save, SaveAs, editor-destroy and WorkbenchClose events.
  • Startup lifecycle guards for theme events and partially initialized Thonny Editor instances.
  • Language-aware completion and localized plain-text snippet templates through Thonny's native completion popup.
  • Signature help through Thonny's native calltip UI.
  • Ctrl+click / Command+click go-to-definition routed directly to the language server.
  • LSP diagnostic underlining and diagnostics command.
  • Pygments-backed multilingual syntax coloring using Thonny syntax-theme tags.
  • Formatting, hover information, rename and language-server restart commands.
  • UTF-32 LSP position negotiation to match Tk/Thonny code-point columns.
  • MkDocs/Material documentation under site/, GitLab Pages CI, PyPI packaging and the standard Yarn workflow.

Thonny Run integration

  • Route Thonny's native Run current script / F5 / green triangle to the same !pseudo <file> command used manually in the Shell for .pseudo and .algo files.
  • Preserve localized Pseudocode runtime/syntax diagnostics and source-line reporting instead of leaking backend Python exceptions.
  • Leave ordinary .py execution on Thonny's original Run handler unchanged.
  • Remove the backend source-preprocessor package now that native Run is dispatched through the Pseudocode CLI.
  • Give diagnostics priority over generic keyword help on pointer hover and strip Markdown fence language markers from plain Tk tooltips.
  • Split the Pseudocode view into Diagnostics, static plugin/developer Information, contextual Help and Flowchart tabs.