We're sorry but this page doesn't work properly without JavaScript enabled. Please enable it to continue.
Feedback

Reviving Reverse Polish Lisp

00:00

Formal Metadata

Title
Reviving Reverse Polish Lisp
Subtitle
Building an open-source HP48-like calculator
Title of Series
Number of Parts
542
Author
License
CC Attribution 2.0 Belgium:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Identifiers
Publisher
Release Date
Language

Content Metadata

Subject Area
Genre
Abstract
The DB48X project aims at recreating an open-source implementation of Reverse Polish Lisp on modern calculator platforms In 1986, Hewlett-Packard introduced the HP28C, and with it, a new programming language, "Reverse Polish Lisp" (RPL). This was arguably one of the most powerful programming languages ever introduced on a pocket calculator, and it continued well into the 2000's, with the HP50 series. RPL was initially designed for a machine with a 4-bit CPU and 2K of memory, soon upgraded to 32K. Some of the more recent calculators from Hewlett-Packard used ARM CPUs, but then only to emulate the original 4-bit CPU and run the older 4-bit ROM code. Today, several ARM-based calculator platforms support open-source firmware. This opens the possibility to revive RPL in a more modern environment. DB48X is an attempt at recreating RPL from scratch to run on such platforms. Even today, these machines remain minimalistic, with as little as 60K of free memory and less than 1MB of usable Flash storage, for example. This talk will present a design and implementation of a basic RPL runtime written in C++, but replacing the standard C++ object model with a compact, garbage-collected, byte-addressable representation of RPL objects. We will also dive into what RPL is, why it truly deserves the name "Lisp", and why it remains remarkably different from the Lisp most of us are familiar with. We will discuss some of the implemented and planned features for that new iteration of RPL, including built-in on-line help, taking advantage of high-resolution graphics, or making it as efficient as possible in "direct" (non-programmed) mode.
14
15
43
87
Thumbnail
26:29
146
Thumbnail
18:05
199
207
Thumbnail
22:17
264
278
Thumbnail
30:52
293
Thumbnail
15:53
341
Thumbnail
31:01
354
359
410
Reverse engineeringReverse engineeringComputing platformElectronic mailing listOpen sourceComputer animation
Web pageReverse engineeringDemo (music)NumberOpen sourceData modelObject (grammar)outputOpcodeParsingPrice indexCodeRead-only memoryType theoryGroup actionSequenceFile formatComputer wormSource codeSpeicherbereinigungVolumenvisualisierungOnline helpSoftwareReal numberObject modelCalculationSpeicherbereinigungComputer simulationComputer hardwareFreewareDemo (music)Compact space
Computer hardwareSimulationDemo (music)Shift operatorAlpha (investment)Mountain passContent (media)Newton's law of universal gravitationLogicKeyboard shortcutDefault (computer science)Directory serviceType theoryAdditionDemo (music)Integrated development environmentLine (geometry)Point (geometry)Sanitary sewerComputer hardwareComputer simulationSoftware testingCalculationSoftwareVariety (linguistics)QR codeCartesian coordinate systemSpacetimeFerry CorstenStructural loadComputer programmingComputer animation
Computer programComputing platformDynamic Host Configuration ProtocolPhysical systemFirmwareRevision controlData typeMenu (computing)Differenz <Mathematik>HyperlinkStack (abstract data type)Functional (mathematics)Key (cryptography)Multiplication signStandard deviationLevel (video gaming)NumberOperator (mathematics)Integrated development environmentComputational sciencePoisson-KlammerTerm (mathematics)Sign (mathematics)CalculationRepository (publishing)Online helpComputer programmingLine (geometry)SoftwareInterface (computing)ResultantReverse engineeringFormal languageInstance (computer science)Endliche ModelltheorieElectronic mailing list
Interactive televisionFormal languagePositional notationReverse engineeringWeb pageComputer programmingPhysical systemBefehlsprozessorImplementationCarry (arithmetic)Hybrid computerAddress spaceCalculationFormal languageInteractive televisionReverse engineeringSign (mathematics)Instance (computer science)Extreme programmingPresentation of a groupDressing (medical)Keyboard shortcutBitAddress spacePoint (geometry)Set (mathematics)Beat (acoustics)Nichtlineares GleichungssystemNumberNetwork topologyFreewareSoftwareBuildingForm (programming)Source codeGoodness of fitSeries (mathematics)Theory of relativity40 (number)Semiconductor memoryPhysical systemCellular automatonMoment (mathematics)Different (Kate Ryan album)1 (number)Thermal expansionVirtual machineBus (computing)ImplementationRow (database)Tape driveComplete metric spaceEndliche ModelltheorieNeuroinformatikRight angleWorkstation <Musikinstrument>Real-time operating systemEmulatorType theoryReal numberPositional notationVariety (linguistics)PlastikkarteSineBefehlsprozessorRepresentation (politics)ArmFirmwareField (computer science)Computing platformCodeProgramming paradigmData acquisitionOpen sourceComputer animation
Computing platformFreewareFirmwareWeb pageReverse engineeringComputing platformSoftwareCalculationForm (programming)Physical lawFreewareNumberFirmwareComputing platformGoogolFlash memoryVideo gameArmTerm (mathematics)Computer animation
Android (robot)Web pageEmulatorFreewareReverse engineeringComputer hardwareBuildingComputing platformFirmwareService (economics)MathematicsOperator (mathematics)Local ringKeyboard shortcutLine (geometry)Coefficient of determinationCalculationInternet service providerFreewareSoftwareComputer-assisted translationComputer hardware40 (number)Different (Kate Ryan album)NumberLogicLevel (video gaming)EmulatorFirmwareComputing platformTerm (mathematics)Type theoryPhysical systemComputer animation
Read-only memoryExt functorGame controllerSoftwareComputer simulationResultantRight angleForcing (mathematics)Computing platformSpacetimePrime idealComputer animation
Web pageReverse engineeringArmVirtual machineLibrary (computing)Floating pointEmulatorTerm (mathematics)DampingPhysical systemCommodore VIC-20Flash memoryNumberComputing platformArmOperating systemFirmwareFloppy diskPower (physics)Electronic mailing listTheory of relativityPoint (geometry)Structural loadComputer animation
ImplementationRead-only memorySpeicherbereinigungWeb pageReverse engineeringNumberIntegerUsabilityModemArray data structureElectronic mailing listWitt algebraRegulärer Ausdruck <Textverarbeitung>Algebraic numberComputer programFunction (mathematics)Variable (mathematics)Fibonacci numberGEDCOMData modelSequenceComputer wormRepresentation (politics)Negative numberObject (grammar)Data storage deviceCompact spaceProgrammschleifeBlock (periodic table)Data typePrice indexCurve fittingType theoryInterrupt <Informatik>Row (database)Loop (music)Performance appraisalFormal languagePhysical lawMultiplication signObject (grammar)Semiconductor memorySpeicherbereinigungMaxima and minimaTemplate (C++)Library (computing)Decision theoryData storage devicePoint (geometry)Bounded variationShared memoryIntelAddress space40 (number)Set (mathematics)Projective planePhysical systemFood energyMenu (computing)Shift operatorTable (information)Row (database)Directory serviceElectronic mailing listFunctional (mathematics)Series (mathematics)Instance (computer science)ResultantKey (cryptography)ExpressionEndliche ModelltheorieComputer programmingNumberCalculationCategory of beingSquare numberINTEGRALHybrid computerSource codePoisson-KlammerVirtual machineType theory2 (number)Subject indexingQuantum stateComputing platformFitness functionData conversionNetwork topologyMathematicsHash functionAssociative propertyCodecMilitary baseMedical imagingPerformance appraisalStrategy gamePotenz <Mathematik>DigitizingFloating pointLevel (video gaming)Variable (mathematics)Loop (music)Content (media)IntegerCursor (computers)MultilaterationRevision controlSoftwareCartesian coordinate systemTangentOrder (biology)BitFirmwareCodeSign (mathematics)Library catalogAlgebraArray data structureException handlingComputer wormMechanism designData type1 (number)RootReal numberDirection (geometry)Computer animation
BefehlsprozessorReverse engineeringElectronic visual displayImage resolutionWeb pagePhysical systemMenu (computing)Complete metric spaceLibrary catalogGEDCOMEmailFibonacci numberNumberMatrix (mathematics)Vector spaceFunction (mathematics)Graph (mathematics)Dressing (medical)Multiplication signFunctional (mathematics)Identity managementCalculationPoint (geometry)Menu (computing)Insertion lossPhysical systemUsabilityInstance (computer science)Computer programming1 (number)Uniform resource locatorForcing (mathematics)ResultantState of matterComplete metric spaceDirection (geometry)NumberShift operatorNetwork topologyRow (database)Shared memoryDeterminantPlanningElectronic visual displaySineSemiconductor memoryReal numberOrder (biology)Medical imagingNichtlineares GleichungssystemStudent's t-testCursor (computers)Equivalence relationComplex numberImage resolutionEndliche ModelltheorieType theoryAlpha (investment)Asynchronous Transfer ModeDemo (music)Absolute valueGreatest elementDoubling the cubeOnline helpComputational scienceKey (cryptography)Parity (mathematics)PlotterTrigonometryGraph (mathematics)Spacetime32-bitSymbol tableMatrix (mathematics)Complex (psychology)Set (mathematics)Metric systemVector spaceOrder of magnitudeAlgebraComputer animation
Presentation of a groupOnline helpMultiplication signComputer animation
Computer fontStructural load2 (number)Different (Kate Ryan album)Program flowchartMeeting/Interview
File formatPhysical systemTerm (mathematics)Scripting languageComputer fontFirmwareMereologyComplex (psychology)Artistic renderingRepresentation (politics)Moment (mathematics)Range (statistics)SpacetimePresentation of a groupTouchscreenSparse matrixBitRepository (publishing)Open sourceSet (mathematics)Form (programming)AlgebraInstance (computer science)Video gameEndliche ModelltheorieTraffic reportingForcing (mathematics)Ocean currentBeat (acoustics)Point (geometry)Meeting/Interview
Computer fontMultiplication signVideo gameMeeting/Interview
Meeting/Interview
Program flowchart
Transcript: English(auto-generated)
Hello, my name is Christophe de Dinochin and today I'm going to talk about DB48X which is my attempt at resurrecting reverse polish lisp or RPL on a modern open source platform.
So first of all, what are we going to talk about? Why revive RPL and why should you care?
I'm going to give a demo of what DB48X looks like both on a simulator and on real hardware. The idea is to have a handy calculator that does tons of stuff for you. Then I'm going to give a brief history of RPL and of pocket calculators, notably
from HP. I'm going to talk about free software on modern calculators. And I'm going, since this is really the topic of this track, to talk about the very minimalist aspects of calculators even today. Here's a quick feature overview.
I'm going to develop this a little with various examples. And I'm also going to explain how this works inside and notably talk about a very compact C++ object model with garbage collection. So let's start by running DB48X.
I'm going to give two demos, one running on simulator and the second one on Swiss micro's DM42 hardware. So the demo on simulator can be found online. You can scan this QR code to see the details of the demo.
The point here is that we have a development environment that simulates at least the user space portion of the application software and will let us perform a variety of online tests automatically that are difficult to do on the physical calculator.
Now on real hardware, what you do is you have a USB interface. You simply load a DM42 program in it. And that's essentially it. When you exit, you have your new environment and you can switch back and forth between
this and for instance, the standard DM42 software. So RPL has a common line where you type, for instance, numbers and you hit enter. And you see that the numbers go on a stack that is used for operations.
When you want to add numbers or subtract them, you will essentially operate on the last two items on the stack and push the result there. Operations like scientific computations operate exactly the same way. They operate on the top level number one of the stack.
In terms of programming, RPL has this special sign bracket that identifies an RPL program and I push the program on the stack. Then I'm going to give it a name. So one plus increments the first level of the stack. And then to execute the program, I simply hit the soft key and you see that every time
I push it, I increment the number on the stack. So fairly simple. There is a built-in markdown help if you hit a key and keep it held. So here we are seeing the feature for that function and then we can explore the hyperlinks.
So it's all markdown based so we can reuse the same help for the GitHub repository and for the calculator itself. Now let me give you a very brief history of RPL. So again, RPL stands for reverse polish lisp and it's an interactive language for calculators
that has been used by Hewlett-Packard from 1984 until 2015. So RPL has an ancestry called RPN, reverse polish notation. And this started with the HP 35 scientific calculator that introduced this system which
saves keystrokes and is very similar to the way you think about the computations you're doing. It also leads naturally to a step-by-step programming model where you simply record keystrokes and the calculator is going to replay these keystrokes.
That was introduced with the HP 65 which was really a marvel for the day. The little slots you see on the side, for instance, are for a card reader so you can actually store your software on little tapes. The last real complete RPN system was the HP 41.
I'm talking about a system because it could be connected to a variety of expansions. There was a bus, you could connect it to printers, to plotters, to data acquisition tools and so on. But there were later machines that appeared after RPL was introduced and still used RPN,
so essentially the main difference being a fixed size for the stack and no real type system. And the high end of that series is the HP 42. Now RPL itself was introduced with the HP 28C in 1984 or 5.
That machine had only two kilobytes of RAM, so that tells you this can run on a very very small system. It also introduced a new Hewlett-Packard CPU called the Salem that I'm going to talk about in a moment. The history code series culminated with the HP 48 series that had equations, larger
graphics, was extensible, so you had slots where you could put memory, ROM cards, etc. And then there were follow-ups like the 49, etc., that were not very different from the 48. That series was recreated with the HP 50G and other calculators like the 38, the 48G2,
etc., that are essentially running the original software designed for the Salem CPU under emulation with an ARM CPU that emulates the Salem, and that gives you a significant
boost in speed, and essentially it executes exactly the same software. Now because the ARM CPU itself is much much faster than Salem, a number of folks started developing software for it, and this series of calculators were based on
somewhat standard platforms that could be flashed, and so people developed open-source software and free software to replace the built-in firmware. An example shown here is NuRPL, which is an ARM native implementation of RPL that is relatively complete as far as the language itself goes, but is missing a number of
features from the original calculator, including graphics, equation editor, etc. Now how does RPL work inside? It's very interesting because it's a very smart, minimalist system. So first of all, it's optimized for the HP Salem CPU, which is a descendant from CPUs
built for earlier calculators, and that's a 4-bit CPU with 64-bit registers designed mostly for floating points. And so you have 4-bit nibbles that you can address individually in memory.
Addresses are 20 bits, that's 5 nibbles, and the 64 bits in the register can be addressed in a variety of ways that correspond to a BCD representation of floating points. So for instance, the X field is for exponent, the M for mantissa, the S for sine. So there is a number of pieces of free software and free calculator firmware that
can run either on ARM-based calculator, and then later led to platforms developed specifically to run this kind of software. In terms of available platforms, if you go beyond the HP calculators, so first of all,
the ARM-based HP calculators can be flashed, so even a lowly HP 20-something can be given new firmware and a new life. You have an example here with something called WP34S, which creates a very advanced
scientific calculator from a very inexpensive HP calculator. There are also a number of free emulators for iOS, Android, etc. So what you see here is a 42 emulator called 342, and Swiss Micros essentially
started building the hardware around this software. So they created the DM42, which runs a variant of 342 with some underlying firmware to provide operating system level services. And so they have this platform, and that same platform just with the firmware flashing
and changes in keyboard can emulate the HP 42, the HP 41, etc. Now third-party firmware has started sprawling like mushrooms, but really large and advanced firmware. There are not that many variants. What you see here is the descendant of WP34S, which is called 43S,
and has a number of really advanced features, but it's essentially still in the same spirit as the RPN calculators. In other words, it's still using the RPN logic with a fixed-size stack and not much
in terms of typing. So my first attempt to enter that space was to port a new RPN to DM42. And so I created a simulator, and you can see the results of this experiment there with a side-by-side setup where you have the DM42 on the left, the HP 50G simulator
in the middle, and the HP Prime simulator on the right. And essentially, my work was to try to make the software more portable, support 1-bit graphics on the DM42, but really take advantage of that platform. And on simulator, it worked pretty well.
The problem is, as I said, this machine is really minimalist, and it turns out that new RPN, as soon as I started trying to run it on the physical hardware, it just did not fit. Why? Because the platform is built around an ultra-low power ARM Cortex-M4F,
which has, among other benefits, that the battery life on a battery like this is up to three years, according to the vendor. Now, that machine has only 96K of RAM and only 70K free after the operating system load. How much is 64K?
Well, that's essentially one Commodore 64 and a half. And a Commodore 64 is not exactly yesterday's machine. There is only two megabytes of flash available. So, again, in terms of old stuff, what remains free once you have loaded standard libraries and the floating-point emulation library from Intel, etc.,
is about 700K. So, that's about the same size as an original Macintosh floppy disk. So, my conclusion within these numbers is that I had better restart from scratch to create a firmware that was redesigned to fit in such a small system.
So, how does that work? Well, first of all, I wanted to use C++ on a modern language with templates and various library utilities, etc., but I needed to have garbage collection for the objects, just like the original RPL, and a very, very minimal memory usage.
Let's start with the features that I implemented today, and that's essentially based on the command set of the whole series from the HP 48SX to the HP 50G. The Intel floating-point library that ships with the platform gives me
34 decimal places for floating-point. So, you see E and pi here with the number of digits that were computed by running the exponential of one and four times dark tangent of one. The platform, so my application software on top of that also supports large integers
like the HP 50G, as well as base numbers that today can be in hexadecimal, decimal, octal, or binary, and I plan to support arbitrary bases between two and 36 in a later firmware revision.
You see here how these numbers are entered in the machine. So, with a hashtag at the beginning, and then when you put this hashtag on the command line, the cursor shifts to B like binary or based, and then I can enter the numbers directly, and the first row of letters
changes directly to let me enter numbers more practically. So, let me show you that live. So, I bring up the calculator, I click on shift base, and you see that I have the hash sign here, and I can say hash 1 to A, and hash 2 to E plus,
and I have my hexadecimal conversion here.
So, as I said, RPL has a number of data types. That includes text, list, and arrays, so the lists are between braces, the arrays are between square brackets, and the text is between quotes. You see a program there on level 2 that takes the hello string,
the world string, then does a plus, and when you evaluate that program, you get hello world. You have also programs and algebraic expressions, so I just showed what a program looks like, but you can also have algebraic expressions written the usual way.
You see here, for instance, square root of sinus of X plus 1. There is a plethora of scientific functions. The catalog in the HP 48 series lists something like 1,700 functions total, a little less than some other models, but it's the order of what you have.
I also already implemented a storage mechanism for persistent values, so variables, directories, etc. And so, what you see here is a three-level menu where, when you hit the key, you evaluate what is inside the variable. When you shift, you will go to the second level in the menu,
and that will read the content of the variable. And if you shift twice, then you're going to the third level of the menu, and you're going to store something in the variable. So again, I can show that live. I'm going to store the result I just had, so execute is for execute equation.
I'm going to call that B, and I do stow, sorry, enter stow. And then, if I go to the recall menu that shows me the variable, and you see my B here, and if I just evaluate B, I have the number I had.
If I shift B, I recall the value, and if I want to store something else in B, I will shift twice, hit that key, and now B is 12. So, as you can see, the system works already at that level.
So, in order to be able to really have something efficient on such a small machine, I had to design a custom object model, and I based it on RPL itself, the historical RPL, but I tried to make it much more compact,
and for instance, I used LEB128 to store all the objects in memory. So, LEB128 is this system used, for instance, in DWARF that encodes integers by having only the last, so you have seven bits per byte, and the last one in the series has a bit clear,
the other has a bit set. So, the type that is the first byte or LEB128 value is an index to the handler table used for evaluation. So, instead of using direct addresses like in RPL, I use an index. And so, that means I can have 128 one-byte types or commands,
and 1600, 384 fit into bytes, and as a reminder, in RPL, that was 2.5 bytes, five nibbles for each type.
So, I'm saving a little here. So, you see here the catalog on the HP 450, I think. So, let me compare and contrast the storage of something like the number one. To be precise, it's the internal number one on the HP 48.
The HP 48 has no real user integers, whereas a DB48X has. So, when you type one, the most compact storage you have for... Sorry, that's actually three.
I got that wrong on the HP 48. So, the value that you see here, that's the prefix. And so, the 02911 is the address of the evaluation handler for integers, and three, that should actually be one,
is the payload. The storage in LEB128 is 14, that's the index for integer types, and 01 is the actual value. And because the high bit is not set, that stops here and we're done. If you look at ABC, how the text ABC is stored,
the prefix in the HP 48 is 02A2C. So, that's the five nibbles address. Then you have the total size, and then you have the ABC encoding itself. Whereas for DB48X, you have the type, which is two, then you have the length, again, encoded as LEB128.
And so, because it's less than 128, it uses only one byte. And then I have the data itself after that. The name ABC is exactly the same encoding, except that the prefix is not the same. And for DB48X, the type shifts from 02 to 01C.
The types themselves change with every bit, by the way. So, that means the evaluation loop is extremely simple. It's essentially the way this works, you can see the code here, is that you're going to take for each object,
you're going to compute its size, skip to the next one, and then call the handler and evaluate that handler. So, it's really evaluating a program in DB48X is extremely fast. And there is a fast simple copying garbage collector. And the picture that was supposed to illustrate that
was apparently garbage collected as well. So, what is the improvement over existing ESP calculators? Well, moving from 4-bit to 32-bit CPU means that it's much, much faster on various tests like loops, et cetera, and between one, two, or three orders of magnitude faster.
Scientific computations are even faster. There is a high-resolution monochrome ink display. That means that when you switch off the calculator, it keeps a picture that you displayed there. And so, we have these fancy off images that you can use.
So, let me show you some examples here. So, you see this is one off image. And if I shift off, then I'm going to see another image. And again, because it's an ink, it doesn't consume any memory. There are three rows for the soft key menu system.
That's an improvement compared to the original HP calculators. Because of the high-resolution display, we can display the functions associated with base function, shift, and double shift. And as I pointed out earlier, the highlighted portion in black
moves as you hit the shift key. So, let me show that again. So, you see that if I hit the shift key once, then I get to recalling the value B. And if I hit twice, then I move that and then back to the original location.
There is a common catalog and auto-completion. So, that's better shown than explained. So, let me type. So, let me go back to my demo system here. So, let's say that, so if I hit the shift key and I hold it, I shift to alpha mode.
And now I'm going to type, for instance, A. And we are going to see nothing because I was still in the recall menu. I hit plus. And you see that now I have auto-completion at the bottom with the various commands that begin with A. There is a plus here and you might wonder why the plus is here. It's because it also takes the name add.
So, add contains an A. And I have ABS for instance, and now I can do ABS. And I have evaluated ABS of 12 directly. So, that's pretty neat. That's a good way to quickly access a very, very large number of functions. And it's optimized for the original gm42 key layout.
I paid a lot of attention to this. So, for instance, I showed earlier how, for instance, when you type execute, which is execute a command in the gm42, there is no real equivalent for the RPL model.
So, instead, I re-translate that as execute equation. And that does something that is very frequent in RPL, which is to have a symbolic value for something. You can see also that the cursor is moving,
is changing depending on what I'm doing. So, for instance, here it's A for algebraic. And it's white because I'm in alpha mode. If I leave alpha mode, it's going to turn black, but I'm still in algebraic mode. The row keys are, I have only two. The HP 48 has four. So, on the command line, up and down,
move left and right. It's an acquired paste. There is also no real run stop for programs. So, RS is instead translated as eval. So, it evaluates the value that you have there.
And as I said, there is this markdown based online help. So, you saw that in the video, but we can show it live now. So, for instance, if I hit sin and I hold sin, then it's going to show the online help there. You see that there is this home button. So, I can go to home and then I can go down
and select, for instance, the first entry there. And I'm going to jump to help. And that explains how the help system works. So, there is a lot that remains to be done. The future plans include support for complex numbers
that are not implemented yet, vector and metrics arithmetic, which is integral to the HP 48 RPL variant that also existed within 28, et cetera. That's a relatively complex set of things in particular because I would like to do it like new RPL does,
where new RPL does support matrices with symbolic values in there. So, you can have a matrix with an X in there and as the determinant of that matrix, you're going to get the result. Whether I can fit that in the variable space is unclear. As I said, there are about 1,500 functions
that remain to be implemented in some way, including variants. So, for instance, the same function for sinus, the sine-cosine function, all the trigonometric are implemented for real numbers, but they are not implemented for complex numbers yet or for other data types.
So, there is some work that remains to be done also even on existing functions. Plotting and graphing is a key feature of these calculators. So, I'd like to have that. The HP50G is quite advanced in that respect and getting to the point where we have feature parity
is going to take a lot of time. So, that's essentially what I had to show. I hope that you found this interesting and I'm really welcoming contributors if you want to take a look at how this works inside and if you want to help me add many of the new features
or if it were only just to write or extend the online help, any kind of help is really welcome. And that's about it. Thanks a lot for listening. Now it's time for questions, and the questions will be live and I'll have a calculator available if you want to play with it.
So, we should be live now. We have only 30 seconds left, yeah. So, how do the fonts work on these calculators? Is it possible to load custom fonts for different scripts?
Okay, so there are two parts to this question. The first one is the fonts themselves and the second one is non-Latin scripts. So, in terms of fonts, there were multiple formats that I tried.
The current model, the current firmware supports two formats that I call Dense and Sparse. The Sparse format is more efficient for large fonts that have a lot of space and the Dense format is more compact for smaller fonts that have something like,
for instance, if you have a five or eight bits of hate for very small fonts, then practically all pixels inside are used and so you have a Dense format for that. So, that's for the representation of fonts. All the wrong presentations
cover the 16-bit range of Unicode and so they do include most of the known, oh. Yeah, we got cut off. Yeah, so we do cover
an arbitrary range of non-Latin characters. What the system lacks at the moment is that it doesn't know how to do combining glyphs and it doesn't know how to do right-to-left rendering.
Those are a bit complex. They are not implemented in the firmware at the moment. The font that, and then I wrote in the GitHub repository there is a tool that lets you convert any TTF font to use as a font in the system.
The font that I used is derived from an open source font and I forgot what the name is and I changed a few glyphs inside just to make them look better on the screen.
So, you can look at the GitHub history and you'll see that I tried a dozen fonts till I found one that I thought would look good. Okay, thank you. So, thanks for speaking at first and first up. I'll catch you next time. You can hang out in this room
if people want to come and chat with you. This is a breakout room just for this talk. Yep. Thanks a lot. Yeah. Bye.