Glyport
The manager state, ranks and placeholder-font experiments show raw container identity, retained rank caches, debug/shared construction, observer cleanup and source-derived font/error control flow over visible owned primitives. Actual native fonts/defaults/resources remain separately qualified.
The sidebar and document guide explains dynamic tree filtering, defaults, row ownership, list expansion, count publication and document-selected local loading with independent executable owned experiments.
The numerical ordinary-artifact results below identify their retained predecessor
checkpoint. The current manager/profile guide documents
the H source changes. Earlier source assumptions are corrected below; original
preimages remain in verification evidence. Old receipts do not qualify the new
ordinary tuple or native behavior. Run the owned graph setup
first for examples using owned_parsed_manager; those examples explicitly select
actual parsed owned data before a metadata refresh or rename.
Glyport runs Glyphs scripts and plugins inside FontLab. It inspects and adapts
the original source (including Glyphs 2 / Python 2 code), gives each run a live
GlyphsApp model backed by the FontLab font, and translates Vanilla, AppKit and
NIB/XIB interfaces to FontLab's Qt. Original files are never modified.
The detached-transform examples below were checked with the ordinary development
artifact 1.0.8.dev58+g753b55548 and App 0.2.26.dev159+gb1e905b61. They do not
claim a published release or qualify native FontLab behavior. Older packages may
not have the same input checks or overflow preflight.
Install
Install fontlab-glyport into FontLab's Python folder together with a matching
fontlab-fontlabapp; see Install into FontLab.
Its dependencies include fissix and glyphslib. Its inspection API also works
outside FontLab. Glyport never installs packages for you.
Quick start
Assess a script without running it:
from fontlab_glyport import inspect_source
assessment = inspect_source("OriginalScript.py")
print(assessment.required_capabilities)
For ordinary Glyphs imports, activate Glyport on FontLab's GUI thread first. The
default profile is glyphs4; pass profile="glyphs3" or "glyphs2" to match
the script, and call deactivate() when you are done:
import fontlab_glyport; fontlab_glyport.activate()
from GlyphsApp import *
Run a Glyphs script inside FontLab:
# Inside FontLab
from fontlab_glyport import run_script
handle = run_script("OriginalScript.py") # profile chosen from the source
print(handle.state, handle.receipt)
handle.close()
Examples
Install a plugin bundle and remove it again:
from fontlab_glyport import install_plugin
plugin = install_plugin("MyReporter.glyphsReporter")
# ... the reporter now draws in the Glyph window ...
plugin.unload() # removes every registration
Adapt Glyphs 2 source into an owned cache, keeping a map back to original lines:
from fontlab_glyport import adapt_source
adapted = adapt_source("OldScript.py", profile="glyphs2", cache_dir=".glyport-cache")
code = adapted.compile() # compiles; does not execute
print(adapted.translate(1, 1)) # generated position -> original position
Work with detached geometry
These examples run outside FontLab. They create Python-owned draft objects and change no open font. They demonstrate Glyport's arithmetic and object semantics; they do not test copying a native layer, native rounding, Undo or saved fonts.
Apply one affine matrix
The six values (a, b, c, d, tx, ty) map a point as
x_new = a*x + c*y + tx, y_new = b*x + d*y + ty. This example changes a path
and an anchor on an owned detached layer. It does not resolve components or
measure a native layer's bounds.
from fontlab_glyport.model import GSAnchor, GSNode, GSPath
from fontlab_glyport.model.copies import DetachedLayer
layer = DetachedLayer()
layer.paths = [GSPath([GSNode((2, 3)), GSNode((-4, 5))])]
layer.anchors = [GSAnchor("top", (11, 19))]
layer.applyTransform((2, 1, 3, 4, 5, 6))
assert [tuple(node.position) for node in layer.paths[0].nodes] == [
(18, 20), (12, 22)
]
assert tuple(layer.anchors[0].position) == (84, 93)
Composition order matters. A clockwise rotation followed by one combined scale/shear matrix differs from scale, then shear, then counterclockwise rotation. Do not use a similarly named menu as proof that two scripts implement the same transform, layer scope or component policy.
Reject invalid coefficients and overflow before writing
Layer/path transform entry points reject NaN and infinity before backend calls, history or geometry mutation. Finite zero and negative scales retain their existing behavior; this check does not forbid flattening or reflecting geometry.
from fontlab_glyport.model import GSNode, GSPath
path = GSPath([GSNode((2, 3))])
before = [tuple(node.position) for node in path.nodes]
try:
path.applyTransform((float("nan"), 0, 0, 1, 0, 0))
except ValueError as error:
print(error)
else:
raise AssertionError("The non-finite matrix should be refused.")
assert [tuple(node.position) for node in path.nodes] == before
Finite coefficients can still overflow when multiplied by a large coordinate. Python-managed paths, detached layers and selection-aware layer transforms calculate all results before entering history or writing. A failure on a later point therefore leaves earlier points untouched:
from fontlab_glyport.model import GSNode, GSPath
path = GSPath([GSNode((2, 3)), GSNode((1e308, 5))])
before = [tuple(node.position) for node in path.nodes]
try:
path.applyTransform((2, 0, 0, 2, 13, -7))
except ValueError as error:
print(error)
else:
raise AssertionError("The overflowing result should be refused.")
assert [tuple(node.position) for node in path.nodes] == before
This is arithmetic preflight, not a transaction. Setter failures after preflight,
native coordinate conversion, and the native whole-layer transform remain outside
that guarantee. The native layer route calls FontLab's flLayer.applyTransform;
it must not be assumed to preserve metrics and guides like the detached example.
Repeated objects are transformed per occurrence
The following deliberate alias illustrates draft-object identity. It is not a recommendation to create duplicate nodes in a font. Each occurrence uses the previous virtual result, so two factors of two give a factor of four. If a later occurrence overflows, preflight refuses the operation before the first write.
from fontlab_glyport.model import GSNode, GSPath
node = GSNode((2, 3))
path = GSPath([node, node])
path.applyTransform((2, 0, 0, 2, 0, 0))
assert tuple(node.position) == (8, 12)
This identity rule covers the same draft object and ordinary cached live proxies. It does not prove equivalent behavior for distinct wrappers sharing external storage. A script that repeats a parent glyph may also need to recompute each layer's bounds between visits; repeatedly applying one fixed matrix is not a substitute for that workflow.
Distinguish layer names from layer identity
A layer's name is not its identifier. Ordinary auxiliaries have their own
layerId and an associatedMasterId; a missing name must not make an auxiliary
look like its master. Use the ID to address a layer, and keep the raw name when
checking a source script's condition. Converting it with str() turns None
into the text "None"; if not layer.name also matches an empty string.
| Layer | Raw name |
isMasterLayer |
Matches name is None and not isMasterLayer |
|---|---|---|---|
| Master | Master name | True |
No |
| Unnamed auxiliary | None |
False |
Yes |
| Empty-string auxiliary | "" |
False |
No |
| Named auxiliary | "Backup" |
False |
No |
The following diagnostic fixture runs outside FontLab. FakeBackend is a test
double, not a font importer. It supplies the three auxiliary name values to the
same proxy model used by Glyport. The example reads every glyph, keeps names
unmodified and collects matching identities without deleting anything.
from fontlab_glyport.model import Model
from fontlab_glyport.model.backend import LayerInfo
from fontlab_glyport.model.fake_backend import FakeBackend
backend = FakeBackend()
for identity, name in [("unnamed", None), ("empty", ""), ("backup", "Backup")]:
backend.layers["glyph", identity] = LayerInfo(
id=f"layer-{identity}", masterId="master", width=500,
layerId=identity, name=name,
)
font = Model(backend).font
layers = list(font.glyphs[0].layers)
assert [layer.name for layer in layers] == ["Regular", None, "", "Backup"]
assert [layer.isMasterLayer for layer in layers] == [True, False, False, False]
assert layers[1].associatedMasterId == layers[0].layerId
assert font.glyphs[0].layers["unnamed"] is layers[1]
assert layers[1].copy().name is None
matches = [
(glyph.name, layer.layerId)
for glyph in font.glyphs
for layer in glyph.layers
if layer.name is None and not layer.isMasterLayer
]
assert matches == [(font.glyphs[0].name, "unnamed")]
All fixture layers have empty geometry, but only the absent-name auxiliary matches. The condition describes a missing name, not an empty outline. It also has whole-font scope; substituting selected glyphs changes the workflow.
This example was verified with the private, uncommitted development artifact
1.0.8.dev58+g753b55548.d20261101. The earlier clean artifact
1.0.8.dev58+g753b55548 fails the raw-name assertion: its proxy substitutes the
master name for both None and "". Master and background naming retain their
existing behavior in the repaired candidate. This is not a published release.
The fixture does not show whether FontLab's importer preserves a Glyphs None
name or converts it to an empty string. Do not use this filter as a qualified
native deletion script. Removing layers additionally requires preservation of
locks, active layers, automatic dependants, history and saved/reopened payloads.
Those native workflows remain unverified. The broader Layer Cleanup menu has
its own explicit selection and layer-kind behavior; it is not an equivalent
implementation of this predicate.
Query glyph metadata without copying the current encoding
A glyph's stored Unicode is editable font data. A name-based Glyph Info lookup asks for database metadata. These differ when a glyph has been re-encoded: a script that resets Unicode cannot use the current encoding as its reference.
Omitting font or passing font=None queries the shared manager without reading
the active font. An explicit font selects font.glyphsInfo(); the earlier
unconditional .localData refusal is superseded. Integer Name dispatch differs
by complete Glyphs2/3/4 profile. The manager/profile guide
provides current document selection, exact keywords, formatting, forwarding and
provider examples. Its default Glyphs4 Unicode keyword is string_or_int;
Glyphs2/3 retain String with their separate integer contracts.
This diagnostic fixture runs outside FontLab. It instantiates the application
facade with owned model/bridge doubles; it does not activate GlyphsApp, load a
native host or edit an open font. The deliberately incorrect encoding on A
remains untouched after the query.
from types import SimpleNamespace
from fontlab_glyport.errors import UnsupportedCapability
from fontlab_glyport.glyphsapp.application import GSApplication
current_glyph = SimpleNamespace(
name="A", unicode="0042", category="Symbol", subCategory=None, script="custom-script", case=2, layers=[],
)
local = owned_parsed_manager()
current_font = SimpleNamespace(glyphs={"A": current_glyph}, glyphsInfo=lambda: local)
model = SimpleNamespace(font=current_font)
# This fixture never calls bridge methods or reads/writes persistent defaults.
app = GSApplication(model, object(), {}, None, lambda *args: None)
info = app.glyphInfoForName("A")
assert info.unicode == "0041", "Name-derived data must not copy current encoding"
assert info.category == "Letter"
assert info.script == "latin"
assert current_glyph.script == "custom-script", "A lookup must not edit script metadata"
# Filter by database script metadata; an unassigned script remains None.
names = ["A", "Alpha", "alpha", "acutecomb"]
greek = [name for name in names if app.glyphInfoForName(name).script == "greek"]
assert greek == ["Alpha", "alpha"]
assert app.glyphInfoForName("acutecomb").script is None
# Case is a database enum: upper=1, lower=2, not a Unicode category.
case_names = ["A", "a", "exclam", "less", "acutecomb"]
upper = [name for name in case_names if app.glyphInfoForName(name).case == 1]
lower = [name for name in case_names if app.glyphInfoForName(name).case == 2]
assert upper == ["A", "exclam"]
assert lower == ["a", "less", "acutecomb"]
assert app.glyphInfoForName("acutecomb").category == "Mark"
assert current_glyph.case == 2, "A lookup must not edit case metadata"
assert app.glyphInfoForName("A", font=None).unicode == "0041"
assert current_glyph.unicode == "0042", "A lookup must not edit the glyph"
assert app.glyphInfoForName("A", font=current_font) is local.glyphInfoForName_("A")
assert current_glyph.unicode == "0042", "Explicit lookup must not edit current encoding"
The read-only script field snapshots metadata supplied by the database. This
example uses it to select Greek names without changing the font. An unassigned
script stays None; do not treat that as a missing glyph or invent a script from
its Unicode.
The read-only case field also snapshots database metadata. Its values are
no-case (0), upper (1), lower (2), small-caps (3), minor (4) and other (5).
They are not Unicode general categories: exclam has upper case metadata,
while less and the combining mark acutecomb have lower case metadata.
Missing case metadata maps to no-case; an unknown label raises an unsupported
capability error. Other Glyph Info fields remain incomplete.
This fixture needs the private global-lookup, script-field and case-field repairs.
Several uncommitted builds share 1.0.8.dev58+g753b55548.d20261101; version text
alone does not identify them. The earlier lookup-only build raises an unsupported
attribute error at info.script; the later script-only build fails at the first
.case read. These archives are not published releases.
Tested private archive SHA256 values:
| Archive | SHA256 |
|---|---|
| Wheel | f174ab43d51c83dd1115e1509bd5920db5bee77cf771bffe1ca98fca8f8d3679 |
| sdist | 64793db733288cef3131f14e47ff9b1074425d6f5e82487ceb62bcf353242eb6 |
The fallback does not load Glyphs’ custom global GlyphData overlays. Name-based
unknown-name results and full GSGlyphInfo records also remain incomplete.
The new global Unicode route has its own audited raw-spelling synthesis; it does
not establish arbitrary name-factory synthesis or proprietary data completeness.
This example qualifies the default lookup's independence from font data, not
complete Glyphs database equivalence or a native Unicode-reset workflow. The
legacy Unicode and ROS guide covers the newer
GSGlyphInfo.unicodeLegacy snapshot, canonical aliases and active-font isolation.
Legacy Unicode remains separate from the primary encoding. The corrected source
candidate implements
Glyphs.glyphInfoForUnicode(String, font=None)
with exact uppercase lookup in the shared primary/legacy index, followed by
source-backed synthesis only on a miss. In source order each record contributes
primary keys then its legacy key; later assignments win. FE8D selects
alef-ar.isol with primary Unicode None, and duplicated 0000 selects NULL.
The corrected ordinary six-wheel cohort passes all 24 owned examples across the
parameter, metadata and Unicode guides, with installed origins checked. All 701
runtime/data files match byte for byte before and after consumer execution. It passes 4,481 Scriptmix tests
with 1 existing skip (Spacing Preview has no selection read) and 2,436 Examples
tests without skips;69 original Scriptmix hashes are independently audited.
The corrected Glyport wheel SHA256 is
607ed7a0417120dd12f486ee9fc72f0d2ddbb78bbd2a6242ecdf79897a68cc20.
The current Echopy wheel SHA256 is
8f74fa6ae7d9041103d6516c1360bd66a412e7f12333142153a09bca83342fc7;
its sdist SHA256 is
e678a77c6178894dfe4f7b363825999e39ae166feec83d95a5af24d85e88ed7d.
The exact six-wheel tuple is:
| Package | Version | Wheel SHA256 |
|---|---|---|
| fontlab-fly | 0.2.3.dev7+g42d106154 |
191b1daff6ac075c84737a5b377e97aecbc94eb7a7338530e941b1e864ec7eb6 |
| fontlab-fontlabapp | 0.2.26.dev332+g73011d1ee |
f31a76c7450a1c75f5412c243c2aa1facfaa9905de3fa2f1c0dd83b29acf5716 |
| fontlab-fontport | 1.0.3.dev23+gcdf5200cc |
294d0e66d992db651aaa1d1c00c4d9c849145cc7e7bf368b676e7102005e0c1c |
| pythonqtside | 0.2.2.dev2+g52d226291 |
27e49b526266e5a924d463cddeffacfb1bbd7fe690e4ebb230d8daa77dd91c6f |
| fontlab-glyport | 1.0.8.dev182+g94d4226dc.d20261101 |
607ed7a0417120dd12f486ee9fc72f0d2ddbb78bbd2a6242ecdf79897a68cc20 |
| fontlab-echopy | 0.2.4.dev9+gac22b37ea.d20261101 |
8f74fa6ae7d9041103d6516c1360bd66a412e7f12333142153a09bca83342fc7 |
The other four wheels and 40 third-party pins are unchanged. Independent ordinary wheel and complete 144-member-sdist installs each pass 32 isolation checks, 356 Echopy tests,388 Glyport feature tests and14package examples, with project origins confined to each installed prefix. A standard build from the extracted sdist reproduces the source wheel byte-for-byte. All 13 Echopy producer catalogues match current source; only GlyphsApp shim provenance changes at runtime, with all 124 protected declarations/exports unchanged. This is producer refresh, not a new FontLab 9.0.9801 capture. Earlier archive hashes and results stay historical. Remaining fields, bridge conversion, local managers and native workflows remain separate acceptance boundaries. The upstream lookup contract describes the optional font-local database behavior still to implement.
Preserve a glyph's case override
GSGlyph.case is mutable glyph metadata; GSGlyphInfo.case above is a read-only
database snapshot. A glyph can have a temporary case value while storeCase is
false. Setting that flag to true preserves the current value through supported
name changes and metadata refreshes. Setting an attached glyph's flag from true
to false restores its database default. Assigning false when it is already false
leaves a temporary value intact.
The following owned fixture runs outside FontLab. It demonstrates the same
minor-figure predicate used by kerning scripts, then changes case without editing
an open font. FakeBackend supplies the attachment target; it is not a font file.
from fontlab_glyport.errors import UnsupportedCapability
from fontlab_glyport.model import GSGlyph, Model
from fontlab_glyport.model.fake_backend import FakeBackend
names = ["A", "ordfeminine", "one"]
assert [name for name in names if GSGlyph(name).case == 4] == ["ordfeminine"]
glyph = GSGlyph("f_f_i")
assert glyph.case == 2
glyph.case = 3
assert glyph.storeCase is False
glyph.storeCase = False
assert glyph.case == 3 # An unchanged flag does not refresh metadata.
font = Model(FakeBackend()).font
font.parent._local_glyph_info = owned_parsed_manager()
font.glyphs.append(glyph)
assert glyph.case == 3 # Unique attachment retains the temporary value.
glyph.storeCase = True
glyph.name = "less"
assert glyph.case == 3 # The stored value survives this name change.
glyph.storeCase = False
assert glyph.case == 2 # Attached reset restores the database classification.
copied = glyph.copy()
copied.storeCase = True
copied.case = 5
assert glyph.case == 2
try:
copied.storeCase = False
except UnsupportedCapability as error:
assert error.capability == "GSGlyph.storeCase.detachedReset"
else:
raise AssertionError("Detached reset is not yet qualified")
assert (copied.case, copied.storeCase) == (5, True)
Detached true-to-false reset currently refuses before mutation; its upstream
manager behavior still needs qualification. Custom global/font-local databases,
synthesized names and complete updateGlyphInfo behavior remain incomplete.
That historical candidate refused unknown-name updates. This fixture does not prove
native history, saved/reopened metadata or complete kerning-script workflows.
The lifecycle candidate uses the same private development version as the earlier case-field build above. These new archive hashes identify the added behavior:
| Archive | SHA256 |
|---|---|
| Wheel | 4054cafb86a86559711361314f9ea0f29812e1b05ee8c985cdc56134a6bc2633 |
| sdist | 8ea0e2ba569df0a662fbc0da17f0a36a48591c333449867891bb931ecce1288e |
Preserve a glyph's script override
GSGlyph.script reads named-glyph metadata, including for unencoded glyphs.
Assignment changes the current value without enabling storeScript. An enabled
flag preserves the value through supported name changes and refreshes. Disabling
it on an attached glyph restores the database default. An already-false flag
leaves a temporary assignment intact. None and an empty string are distinct
explicit values.
This owned fixture runs outside FontLab. It exercises the draft-before-append pattern used by script builders, followed by a stored override and reset.
from fontlab_glyport.model import GSGlyph, Model
from fontlab_glyport.model.fake_backend import FakeBackend
font = Model(FakeBackend()).font
font.parent._local_glyph_info = owned_parsed_manager()
glyph = GSGlyph("f_f")
assert glyph.script == "latin"
glyph.script = "Rovas"
glyph.storeScript = False
assert glyph.script == "Rovas"
font.glyphs.append(glyph)
assert glyph.script == "Rovas"
glyph.storeScript = True
glyph.name = "Alpha"
assert glyph.script == "Rovas"
glyph.storeScript = False
assert glyph.script == "greek"
glyph.script = None
assert glyph.script is None # Explicit None does not fall back to Greek.
copied = glyph.copy()
assert copied.script is None
copied.script = ""
assert copied.script == "" and glyph.script is None
with font.glyphsInfo()._scope():
copied.name = "A-cy"
assert copied.script == "cyrillic" # A known name refreshes unstored metadata.
Detached true-to-false reset refuses before mutation, as with case metadata. Custom metadata managers, synthesized names, complete original-script workflows, native Undo/Redo and saved/reopened metadata remain unqualified. The fixture uses an owned backend double and does not edit any font file.
The script-lifecycle candidate retains version 1.0.8.dev58+g753b55548.d20261101.
These hashes distinguish it from the earlier case-only artifacts:
| Archive | SHA256 |
|---|---|
| Wheel | 383ab1378bcea5e60034ba3548348d19d46734efb2e1a64f5a9bef641ccaafdc |
| sdist | 9218f4a61318f3cccb895e53b479711c60ce056858eecfba5097e75fe3715580 |
Classification and shared resolver
The source candidate now supports independent category, subCategory,
storeCategory and storeSubCategory values. Classification accepts strings,
including the empty string, or None. Assigning Unicode alone does not refresh
classification. Turning an enabled storage flag off refreshes only that field;
a flag already off is a no-op. Detached resets remain explicitly unsupported.
Case, script and classification resets share Unicode-first resolution. For an
A encoded as 0061, case resets to lowercase; for 0A15, script resets to
Gurmukhi. The first resolvable encoding wins, including synthesized metadata:
an unassigned 0378 prevents a later 0A15 from supplying Gurmukhi metadata,
while 10FFFF, which yields no record, allows the next encoding to be tried.
The Icon and SF-Symbol categories use the audited keep-name path.
This owned example exercises the shared resolver without opening FontLab:
from fontlab_glyport.model import Model
from fontlab_glyport.model.fake_backend import FakeBackend
font = Model(FakeBackend()).font
glyph = font.glyphs["A"]
glyph.unicodes = ["0061"]
glyph.category = "Symbol"
glyph.storeCategory = True
glyph.case = 3
glyph.storeCase = True
glyph.storeCase = False
assert glyph.case == 2 # Unicode metadata wins over the name A.
assert glyph.category == "Symbol" and glyph.storeCategory
glyph.storeCategory = False
assert glyph.category == "Letter"
assert glyph.name == "A" and glyph.unicodes == ["0061"]
These are owned offline checks against retained upstream analysis, not native measurements. Custom data, full ROS mapping, complex small-cap mapping and language suffixes remain unqualified. The current private parameter/presentation update is described in the ordered parameter guide. Additional encodings now follow the audited helper gates; native workflow acceptance remains open. Earlier artifact hashes and examples above identify their historical, narrower candidates; they do not identify this source revision.
Additional encodings during refresh
Refreshing an attached uppercase glyph can add its lowercase encoding when no
other glyph owns that code. I can also gain dotless i; each ownership check is
independent. Refresh applies the resolved metadata’s encoding list plus these
additions; it does not preserve every arbitrary previous glyph encoding.
Additions preserve the resolved list’s order and do not duplicate its entries.
This uses the glyph's current case/script, including temporary overrides, before
stored metadata overlays. Resetting a storage flag does not write encodings.
The owned example below runs without FontLab:
from fontlab_glyport.model import GSGlyph, Model
from fontlab_glyport.model.fake_backend import FakeBackend
font = Model(FakeBackend()).font
font.parent._local_glyph_info = owned_parsed_manager()
glyph = GSGlyph("I")
font.glyphs.append(glyph)
glyph.updateGlyphInfo(changeName=False)
assert glyph.unicodes == ["0049", "0069", "0131"]
glyph.updateGlyphInfo(changeName=False)
assert glyph.unicodes == ["0049", "0069", "0131"] # No duplicates.
other_font = Model(FakeBackend()).font
other_font.parent._local_glyph_info = owned_parsed_manager()
other_font.glyphs.append(GSGlyph("i"))
capital = GSGlyph("I")
other_font.glyphs.append(capital)
capital.updateGlyphInfo(changeName=False)
assert capital.unicodes == ["0049", "0131"] # Another glyph owns ordinary i.
Greek-script expansion requires both Phi and Sigma encodings in the font. U+0130 and the audited out-of-range sentinel bypass expansion. Ordinary rename and explicit refresh remain distinct: rename clears non-PUA encodings before resolution, while a subsequent refresh can add encodings. Parentless glyphs and keep-name categories have separate audited branches. The retained parentless Arabic branch can yield no metadata; it is not equivalent to attached refresh. Legacy-only Arabic .isol data does not become primary Unicode automatically.
The bundled Unicode17 scalar mapping matches actual NSString.lowercaseString for all1,112,064 valid scalars on macOS27.2. Python3.11 casing differs on55scalars. This pins that measured casing contract, not all Foundation versions. The public data and licence ship with the package; no Objective-C bridge is loaded for this operation. Native history/reopen, complete local initialization and full ROS mapping remain unqualified. The newer source/artifact-tested Arabic presentation stage is described in the ordered parameter guide; it does not establish native font-workflow acceptance.
Ordered parameters and Arabic presentation forms
The current private candidate preserves ordered duplicate parameters and live
name/value/active edits. Name lookup selects the first active value; name writes
and removal address the first matching object, even when inactive. Master and
font parameter storage remain distinct from ordinary userData. The Arabic stage
uses the exact Use Arabic Presentation Form Unicodes key and appends maintained
legacy data during an explicit refresh.
Read the parameter and Arabic guide for owned
examples, direct/nil/empty legacy precedence, stored overlays, refresh/reset and
macOS locale/float32 conversion. The legacy Unicode and ROS guide
adds public GSGlyphInfo.unicodeLegacy snapshots, distinct primary/legacy values
and the exact ROS shared-manager refusal/no-op boundary. The five proprietary
map requests refuse before presentation and metadata writes; no maps or
approximations ship. Non-macOS strings, arbitrary object conversion, full ROS
mapping, complete local initialization/private resources and native collisions remain open.
Earlier archive hashes on this page stay historical; they do not
identify this newer source candidate. No published release or native
workflow acceptance is implied.
What is supported
- The private candidate’s global Unicode Glyph Info: exact combined primary/legacy lookup and audited synthesis on a miss, returning read-only name, Unicode, separate legacy Unicode, category, subCategory, script, case and supported component snapshots. Font-local managers, arbitrary bridge inputs, remaining fields and native workflows retain explicit limits.
- The
GlyphsAppmodule for each run:Glyphs, the GS* model classes, callback events and dialogs (Glyport reference). - The seven Glyphs SDK plugin classes (
GeneralPlugin,FilterWithoutDialog,FilterWithDialog,ReporterPlugin,PalettePlugin,SelectTool,FileFormatPlugin), registered as real FontLab menu actions, windows, export items and native Glyph-window painters. Reporters draw through FontLab's native canvas painters (flCanvas.appendPythonPainter): background methods paint under the glyph outlines, foreground methods over them.SelectToolplugins register as native FontLab tools (flWorkspace.registerPythonTool); see Native hooks. - Vanilla controls and dialogs, Qt-backed AppKit classes, NSBezierPath drawing and NIB/XIB interface loading (Glyport reference).
Limits
- Compatibility is partial and still being extended; each run records a receipt
with the outcome, and unsupported features raise
UnsupportedCapabilityat the script line instead of failing silently. - Native tools have no toolbar icon, never claim keys (so FontLab shortcuts keep working, with no shortcut override), and paint only while active. FontLab always reports the active tool as select.
- Bundles that ship only compiled macOS code cannot run.
- Creating glyphs makes FontLab rebuild auto-layer composites. Glyport restores existing composites afterwards and refuses with a named reason when it cannot. A FontLab defect can still drop component locks and attaching anchors on composites it rebuilds.
- Edits on auto layers (outlines, anchors, guides, hints, width, background) are refused before anything changes: telling FontLab about an auto-layer edit makes it rebuild every auto layer in the font.
- Test with a copy of your font: scripts can change the font they run on.
See the Glyphs compatibility guide. Reference: fontlab_glyport.
Compatibility status
Native triage on FontLab 9.0.9802 ran 98 corpus Glyphs plugins and scripts through Glyport on an owned font (final code). Pass means the target loaded, registered its menu, tool or window, ran the hooks the harness could trigger without errors, and closed cleanly. Partial means it loaded and ran but a hook raised. Fail means it did not load or did not close.
| Kind | Targets | Pass | Partial | Fail |
|---|---|---|---|---|
| Reporters | 30 | 14 | 9 | 7 |
| Tools | 7 | 2 | 2 | 3 |
| Filters | 12 | 11 | 0 | 1 |
| Palettes | 7 | 5 | 0 | 2 |
| General plugins | 12 | 4 | 0 | 8 |
| Scripts | 30 | 19 | 1 | 10 |
| Total | 98 | 55 | 12 | 31 |
A pass does not prove a plugin's whole behaviour: buttons, dialogs, filter output and outline edits were not exercised, and filters were only installed. Main known gaps:
- Compiled Objective-C bundles (for example ShowAngledHandles) have no Python entry point and cannot run.
- The triage environment lacked
glyphsLib, which Glyport declares as a dependency. Plugins that import it failed there; a complete install avoids that failure class, so the counts understate what a complete install passes. - Some AppKit and Cocoa members are missing (for example
NSGradient,NSBeepand a few layout and window constants), and a few Glyphs model members are absent.
Stored Glyph Info production
The production metadata guide adds owned
examples for the represented-record GSGlyphInfo.productionName contract:
raw nullable reads, exact-name/alias nil fill, helper output, Unicode and
suffix copies, model overlays and explicit unavailable-source errors. An equal
stored name stays text, and empty text stays empty. These private candidate capabilities now pass source and two independent normal
wheel/sdist prefixes: 5,697 Glyport tests, 370 Echopy tests, 479 focused controls,
46 isolation checks, 15 package examples and all 35 central examples per prefix.
All 702 runtime/data files, six provider versions and 40 pins match the exact
ordinary tuple. Consumers pass 4,481 Scriptmix tests/one existing skip and 2,436
Examples tests. Echopy's 13 producer catalogues are current; its 124 protected
files and all runtime declarations remain unchanged. Prior archive
hashes above identify their historical stages. Those receipts predate the compound
candidate below; glyph production writes, application conversion and full native/
original workflows retain their separate acceptance gates.
Compound Glyph Info
The compound metadata guide adds nine owned examples through actual session exports: raw/shared fill, shallow duplicate positions, helper/raw production, suffix nesting, exact-name precedence, Arabic alternates, read-only metadata and long-production rebuilding. The current Glyport source and genuine archives have separate qualification; Echopy source provenance is regenerated and all 385 source tests pass with actual siblings. The refreshed ordinary provider/consumer/example tuple is still pending. Existing proprietary recipes/optional fields and full custom/local/resource/version/native workflows remain open; declaration currency does not close those gates.
Stored descriptions
The description guide adds seven owned examples
for exact nullable text, alias/Unicode lookup, selected compound seeds, copies,
model snapshots and unknown-source refusal. The source successor passes 6,060
tests and 146,378 public-input comparisons; it adds GSGlyphInfo.desc without
Unicode-name synthesis or private data. Matching Echopy source provenance is
regenerated and all 399 source tests pass with actual siblings.
The H source checkpoint implements the parent-aware GSGlyph.glyphInfo /
GSGlyphsInfo routes. The manager guide covers
the selected manager, six stored overlays, groupIdx/direction, canonical/shallow/
frozen distinctions and qualified custom parsing/finalization/discovery. Its
connected local-manager section adds constructor/reload, base-versus-custom
parsing, sidebar resources, queue identity and precise exception boundaries
through invented lawful dependencies, with seven additional executable examples.
Matching companion archives and the complete ordinary installed tuple remain
separate. Complete default/private resources, native local initialization/reload, the original
HTML tool and native FontLab behavior remain open. Earlier artifact receipts
above retain their historical scope.
Complete generation with owned inputs
The complete-generation examples run all ten Chinese jobs and the full queued Hangul traversal through the actual manager implementation. They inspect fixed ranges, profiles, row fields, collision identity, callback completion order, Jamo links and partial failure state. Their four Chinese banks are explicitly invented lawful inputs. Missing private banks refuse; these examples do not qualify proprietary defaults, native font workflows, history, dialogs or publication.