De-colloquialize the text.

WIP.md

@@ -56,7 +56,7 @@ Per-package content-shape references live in sibling files. Open the relevant on
 - [tbIDE Package](WIP.tbIDE.md) — the addin SDK (type-only compiler package): 23 CoClasses + `AddinTimer` + the HTML/DOM `[COMExtensible]` surface + samples 10–15 idiom map.
 - [WinNativeCommonCtls Package](WIP.WinNativeCommonCtls.md) — VB6-compatible `MSCOMCTL.OCX` replacement: 8 controls + 8 sub-objects + per-control nested enums + 10 module-level enums.
 
-The three "winlibs" packages — [WinServicesLib](WIP.WinServicesLib.md), [WinEventLogLib](WIP.WinEventLogLib.md), and [WinNamedPipesLib](WIP.WinNamedPipesLib.md) — share a load-bearing set of integration idioms: composition-delegation on `EventLog(Of …)`, the `ManualMessageLoopEnter` / `Leave` pattern coupling `NamedPipeServer` to a service's `ChangeState` handler, and `PropertyBag` as the canonical pipe payload. When working on any of the three, check the other two for cross-references.
+The three "winlibs" packages — [WinServicesLib](WIP.WinServicesLib.md), [WinEventLogLib](WIP.WinEventLogLib.md), and [WinNamedPipesLib](WIP.WinNamedPipesLib.md) — share an essential set of integration idioms: composition-delegation on `EventLog(Of …)`, the `ManualMessageLoopEnter` / `Leave` pattern coupling `NamedPipeServer` to a service's `ChangeState` handler, and `PropertyBag` as the canonical pipe payload. When working on any of the three, check the other two for cross-references.
 
 ## Page template
 
@@ -308,6 +308,81 @@ Add a `> [!NOTE]` callout or rewrite the affected section when source diverges.
 
 When in doubt about a tB-specific behavior, check `docs/Features/` and `docs/Reference/index.md` before assuming VBA semantics carry over.
 
+## Plain-English prose
+
+The audience is international: standard-English readers worldwide, often non-native, who may not parse idiomatic software-developer jargon. Use plain English in reference and tutorial prose.
+
+The guiding principle: **replace metaphors imported from outside programming; keep vocabulary with a specific technical meaning inside Win32 / COM / event-driven programming.** If a phrase is the kind of thing a reader would have to look up in a tech blog, it doesn't belong in reference prose.
+
+### Replace
+
+| Term | Use instead |
+|------|-------------|
+| `at rest` (idle state) | idle, in its default state |
+| `bake in` / `baked into` | embedded, stored, included |
+| `broker` (as verb) | manages, handles |
+| `carry` / `carries` (figurative) | has, contains, includes |
+| `catches up` | resumes, processes the queue |
+| `comes up` (a connection) | is established, becomes ready |
+| `drive` / `driven` (figurative) | controlled by, determined by, powered by |
+| `for free` (figurative) | as a side effect, without extra effort |
+| `hand off` / `hand over` / `hand back` | returns, passes, delivers |
+| `hand-rolled` | manually constructed, custom-built |
+| `handful` / `handy` | a few; useful |
+| `heavy hitter` / `heavy-hitter` (figurative) | main items, biggest items, most significant |
+| `in flight` / `in-flight` | pending, in progress |
+| `in one shot` | in a single call |
+| `in order to` | to |
+| `kick off` / `kicks off` | start, begin |
+| `land` (figurative — "where the call lands") | appears, arrives, ends up at |
+| `leverage` / `leveraging` | use, take advantage of |
+| `load-bearing` (figurative) | essential, critical, central |
+| `mid-call` | during the call |
+| `on the wire` | transmitted, over the network |
+| `orchestration` / `orchestrate` | coordination, manual handling |
+| `picks up` (figurative) | receives, reads, captures, inherits |
+| `pinned to` (UI layout) | attached to, fixed to |
+| `reach for` / `reaching into` | use, access |
+| `sensible defaults` | reasonable defaults, or list them inline |
+| `spin up` / `spins up` | start, create |
+| `stash` (as verb) | store, save |
+| `sticks` (figurative — "the zoom sticks") | is preserved, is retained |
+| `surface` (as verb) | expose, appear as, make available, raise |
+| `surface area` (figurative API surface) | set of members, interface |
+| `swallow` (a keystroke) | consume, discard |
+| `taps into` | hooks into, intercepts |
+| `tear down` (figurative) | destroy, unload |
+| `twirling` (UI animation) | spinning, or describe concretely |
+| `under the hood` | internally |
+| `utilize` | use |
+| `walk` (as verb — "walk the chain", "walks the children") | traverse, go through, iterate over |
+| `walks through` (tutorials) | demonstrates, explains, describes step by step |
+| `wire up` / `wired up` / `wired in` | connect, attach, link |
+
+### Delete outright
+
+Vague compliments that add no information. Be concrete instead — if a feature is fast, say what it is faster than; if an API is small, say how many members it has.
+
+- `powerful`
+- `robust`
+- `clean` (as a vague compliment — "clean architecture"; literal uses like "clean shutdown" stay)
+- `rich` (vague — "rich information"; literal "Rich Text Format" stays)
+- `easily` (filler — "easily share" → "share")
+
+### Keep as-is
+
+Don't over-correct these — they are precise technical vocabulary or otherwise pull their weight:
+
+- **Programming / Win32 / COM:** `no-op`, `round-trip` / `round-tripping`, `fire-and-forget`, `marshal` / `marshalled` (between threads), `pump` (messages) / `message pump`, `spawn` (a thread or process), `mixin`, `first-class` (type), `boilerplate`, `falls through`, `short-circuit`, `idiom` / `idiomatic`, `canonical`.
+- **Standard prose:** `ends up`, `modern`, `lightweight`, `talk to` (interop), `out of the box`, `on the fly`, `work around` / `workaround`.
+- **Vivid but tolerable:** `ship` / `ships with`, `bridge` (figurative), `cascade` (figurative), `fold in` (compile-time emit).
+- **Audience-appropriate VB6 vocabulary:** `drop it onto a form`.
+- **Marketing register (Videos section only — promotional copy):** `sneak peek`, `game-changing`, `drop-in`, `seamless`.
+
+### Anchors
+
+Some kept terms are referenced by in-doc anchors. The most prominent is `idiom` / `idiomatic` — `WIP.WinEventLogLib.md` and `WIP.WinServicesLib.md` reference anchors like `#service-host-idiom` and `#composition-delegation-idiom`. Don't rename these casually; if you do, add `redirect_from` aliases to preserve legacy links.
+
 ## Scripts and tooling
 
 Any new helper script (content conversion, link checks beyond `check.bat`, etc.) should be written in **Python**. Do not add new Ruby code to this repo. The only Ruby allowed is the existing Jekyll/`just-the-docs` build chain (`Gemfile`, `Gemfile.lock`, `_plugins/`) — that stays as-is.

docs/Challenges/index.md

@@ -10,6 +10,6 @@ From **#general** on Discord:
 
 [From Wayne](https://discord.com/channels/927638153546829845/927638154192748606/1457062373465788671) in Discord:
 
-> As we kick off 2026, we’re introducing monthly twinBASIC challenges, giving you the chance to win a £100 account credit redeemable against future twinBASIC licences.
+> As we start 2026, we’re introducing monthly twinBASIC challenges, giving you the chance to win a £100 account credit redeemable against future twinBASIC licences.
 
 See this on [twinBASIC Update: January 6, 2026](https://nolongerset.com/twinbasic-update-january-6-2026/) from Mike Wolfe.

docs/Challenges/self-contained_diagnostic_tool.md

@@ -63,7 +63,7 @@ Entries will be judged across multiple categories, including:
 Bonus points may be awarded for:
 
 - Use of newer twinBASIC features (e.g. delegates, generics)
-- Particularly clean or insightful design
+- Particularly clean or insightful design <!-- style: clean is approved here -->
 
 Winner selected at the **sole discretion of the twinBASIC team**.
 

docs/Features/Advanced/API-Declarations.md

@@ -132,7 +132,7 @@ For functions which contain the `va_list` type as part of their arguments the Pa
 
 ## PreserveSig
 
-The `[PreserveSig]` attribute was described earlier for COM methods, but it can also be used on API declares. For APIs, the default is `True`. So therefore, you can specify `False` in order to rewrite the last parameter as a return.
+The `[PreserveSig]` attribute was described earlier for COM methods, but it can also be used on API declares. For APIs, the default is `True`. So therefore, you can specify `False` to rewrite the last parameter as a return.
 
 ### Example
 

docs/Features/Attributes-Intro.md

@@ -15,9 +15,9 @@ Attributes have two major functions:
 
 - to annotate Forms, Modules, Classes, Types, Enums, Declares, and [procedures](../tB/Gloss#procedure) i.e. Subs/Functions/Properties.
 
-Previously in VBx, these attributes, such as procedure description, hidden, default member, and others, were set via hidden text the IDE's editor didn't show you, configured via the Procedure Attributes dialog or some other places. In tB, these are all visible in the code editor. The legacy ones from VBx are supported for compatibility, but new attributes utilize the following syntax:
+Previously in VBx, these attributes, such as procedure description, hidden, default member, and others, were set via hidden text the IDE's editor didn't show you, configured via the Procedure Attributes dialog or some other places. In tB, these are all visible in the code editor. The legacy ones from VBx are supported for compatibility, but new attributes use the following syntax:
 `[Attribute]` or `[Attribute(value)]`
 
-Many new attributes enable the powerful additional language features twinBASIC provides, so some of the following items have their associated attributes included in their description.
+Many new attributes enable the additional language features twinBASIC provides, so some of the following items have their associated attributes included in their description.
 
 See also [the comprehensive reference for attributes](../tB/Core/Attributes).

docs/Features/Compiler-IDE/CodeLens.md

@@ -6,7 +6,7 @@ nav_order: 3
 
 # Run Subs from the IDE
 
-The CodeLens feature allows running Subs and Functions, with no arguments and in modules (but not classes/Forms/UserControls) right from the editor without starting the full program. It has robust access to your code; it can access constants, call other functions both instrinsic and user-define, call APIs, and print to the Debug Console.
+The CodeLens feature allows running Subs and Functions, with no arguments and in modules (but not classes/Forms/UserControls) right from the editor without starting the full program. It has full access to your code; it can access constants, call other functions both intrinsic and user-defined, call APIs, and print to the Debug Console.
 
 Methods eligible to run with CodeLens (when enabled), have a bar above them that you can click to run:
 

docs/Features/Compiler-IDE/Debugging.md

@@ -11,7 +11,7 @@ twinBASIC includes several features to help with debugging.
 
 ## Debug Trace Logger
 
-New to the debugging experience is a powerful trace logging feature that can automatically create detailed logs to either the debug console or a file. Messages can be output to the new system with `Debug.TracePrint`. The logger works both when running from the IDE and in compiled executables.
+New to the debugging experience is a trace logging feature that automatically creates detailed logs to either the debug console or a file. Messages can be output with `Debug.TracePrint`. The logger works both when running from the IDE and in compiled executables.
 
 ![image](../Images/4fc2bf99-2bec-4943-837d-21038d791574.png)
 

docs/Features/Compiler-IDE/IDE-Features.md

@@ -59,7 +59,7 @@ The classic file-based view is still used by default, you can activate the new v
 
 ## View Forms and Packages as JSON
 
-Project forms and packages are stored as JSON format data, and you can view this by right-click in Project Explorer and selecting 'View as JSON'. This is particularly interesting for packages as it exposes the entire code in a much more easily parsed format.
+Project forms and packages are stored as JSON format data, and you can view this by right-click in Project Explorer and selecting 'View as JSON'. This is particularly interesting for packages as it exposes the entire code in a more parseable format.
 
 ![image](../Images/22660f54-ff5d-4b21-93d3-39715f1f35ed.png)
 

docs/Features/Fusion.md

@@ -153,7 +153,7 @@ This explicit path must be set **before** opening any Fusion-backed form or cont
 
 ## Current Limitations
 
-Fusion is a powerful compatibility layer, but not all ActiveX controls are supported.
+Fusion is a compatibility layer, but not all ActiveX controls are supported.
 
 #### Currently NOT supported:
 - Windowless controls
@@ -181,4 +181,4 @@ Mouse events are not currently OLE-translated, therefore mouse event signatures
 
 *twinBASIC Fusion* provides a practical path for modernising applications while retaining compatibility with legacy ActiveX controls.
 
-By leveraging an out-of-process architecture and fast IPC-based communication, *twinBASIC Fusion* enables cross-bitness interoperability while maintaining a familiar programming model.
+By using an out-of-process architecture and fast IPC-based communication, *twinBASIC Fusion* enables cross-bitness interoperability while maintaining a familiar programming model.

docs/Features/GUI-Components/Windowless.md

@@ -101,7 +101,7 @@ redirect_from:
 1. **Render the Entire Form to a Bitmap**
 
    * In VB6: Use `BitBlt` or `PaintPicture` to copy the form’s visible area.
-   * In TwinBASIC: Use the form’s [`Canvas`](../../tB/Packages/CustomControls/Framework/Canvas) or [`ICustomControl.Paint`](../../tB/Packages/CustomControls/Framework/ICustomControl#paint) logic to manually render windowless elements to a bitmap. See the [CustomControls package reference](../../tB/Packages/CustomControls/) for the full framework surface.
+   * In TwinBASIC: Use the form’s [`Canvas`](../../tB/Packages/CustomControls/Framework/Canvas) or [`ICustomControl.Paint`](../../tB/Packages/CustomControls/Framework/ICustomControl#paint) logic to manually render windowless elements to a bitmap. See the [CustomControls package reference](../../tB/Packages/CustomControls/) for the full framework API.
 
 2. **Ensure Windowless Controls Are Painted**
 
@@ -146,4 +146,4 @@ Printer.EndDoc
 ```
 ---
 
-For DPI-aware, multi-monitor layout work, windowless controls can be a powerful tool—especially for static or decorative elements—but they demand more orchestration when interactivity or layering is involved. If you're building a hybrid layout, a mix of both types might give you the best of both worlds.
+For DPI-aware, multi-monitor layout work, windowless controls are useful—especially for static or decorative elements—but they demand more manual handling when interactivity or layering is involved. If you're building a hybrid layout, a mix of both types might give you the best of both worlds.

docs/Features/Language/Inheritance.md

@@ -53,7 +53,7 @@ You can see that the Honk method is only implemented by the parent class, then c
 
 ## **Inherits** for Complete OOP
 
-This is a more robust option for full inheritance and OOP. It supports `Protected` methods and variables that are accessible to derived classes but not outside callers, `Overridable` and `Overrides` syntax, multiple inheritance, and explicit base class constructors.
+This option supports full inheritance and OOP: `Protected` methods and variables accessible to derived classes (but not outside callers), `Overridable` and `Overrides` syntax, multiple inheritance, and explicit base class constructors.
 
 ### Example: Animal Class Hierarchy
 

docs/Features/Packages/Creating a TWINPACK package.md

@@ -25,7 +25,7 @@ Once you've created the project, you should find the extra 'PACKAGE PUBLISHING'
 You should now edit the Namespace, Description, Licence and Visibility properties appropriately by using the package manager 'EDIT' links, which will take you to the individual settings in the `Settings` file.   Once you've edited them, remember to close (and save) the `Settings` file in order for your changes to be reflected in the package manager panel.
 
 - **Namespace:** this is the symbol that will be used to group your components in projects that reference your package.  For example, a package that provides a series of different dialog classes might use the namespace `Dialogs`.
-- **Description:** this is the descriptive text that will appear in the `Settings`->`References` list.  If you plan to share this package, it is wise to think carefully about the description so that others can find your package easily through TWINSERV.
+- **Description:** this is the descriptive text that will appear in the `Settings`->`References` list.  If you plan to share this package, think carefully about the description so that others can discover your package through TWINSERV.
 - **Licence:** this short text appears in the `Settings`->`References` list, alongside the Description.  If you plan to share this package, it is important that you enter this field, and the value you enter here should appropriately match the content of the LICENCE.md file (e.g. 'MIT', 'LGPL' etc).
 - **Visibility:** determines whether the package is visible to only you (PRIVATE) or everyone (PUBLIC).  The value set here only takes effect when you use the 'PUBLISH THIS PACKAGE' button to publish your package in the package manager service, TWINSERV.
 

docs/Features/Packages/Updating a package.md

@@ -32,7 +32,7 @@ then it's done and ready to be saved when a second message saying
 
 `[PACKAGES] downloading package '{1FCDB98D-617D-4995-9736-2ED0E4746A10}/8/7/0/498' from the online database... [DONE]`
 
-comes up. It will also go from the checkbox twirling to the entry being moved to the top (below built in packages) with `[IMPORTED]` prepended to it.
+comes up. It will also go from the checkbox spinning to the entry being moved to the top (below built in packages) with `[IMPORTED]` prepended to it.
 
 Restart the compiler if it doesn't on its own after saving, but it usually does.
 

docs/Features/Packages/index.md

@@ -16,6 +16,6 @@ A twinBASIC package is distributed as a TWINPACK file that contains everything n
 
 With TWINPACK packages you group common components together into their own namespace whilst allowing for convenient code reuse without any of the problems often associated with using external DLL libraries.
 
-twinBASIC comes complete with a package manager service called TWINSERV, allowing you to easily share and distribute TWINPACK packages to other twinBASIC developers.
+twinBASIC comes complete with a package manager service called TWINSERV, allowing you to share and distribute TWINPACK packages to other twinBASIC developers.
 
 Please be aware that TWINPACK files currently contain the full sourcecode of your packaged components.  It is planned that we will in future allow for creating binary (compiled) TWINPACK files for developers that hold an Ultimate edition licence of twinBASIC.

docs/Features/index.md

@@ -11,7 +11,7 @@ has_toc: false
 
 This section documents all the features and enhancements that twinBASIC brings compared to VBx and earlier BASIC dialects. 
 
-twinBASIC maintains backward compatibility with VBx syntax while providing these powerful new features. Most enhancements are opt-in, allowing you to gradually adopt them in your projects.
+twinBASIC maintains backward compatibility with VBx syntax while providing these new features. Most enhancements are opt-in, allowing you to gradually adopt them in your projects.
 
 For detailed documentation on each feature, navigate to the specific category listed below.
 

docs/Miscellaneous/FAQs.md

@@ -275,7 +275,7 @@ For an existing project, the Project Scope Option Explicit can be turned on or o
 <summary markdown=span><b>Does twinBASIC support addins?</b></summary>
 {: #addins }
 
-Addins for VB6 and VBA are not supported by the twinBASIC IDE. However, tB has its own powerful addin infrastructure based on modern web technologies. See Samples 10 through 16 in the 'Samples' tab of the New Project dialog:
+Addins for VB6 and VBA are not supported by the twinBASIC IDE. However, tB has its own addin infrastructure based on modern web technologies. See Samples 10 through 16 in the 'Samples' tab of the New Project dialog:
 
 ![image](Images/0e24eb5c-c9af-49a9-a908-03968b211554.png)