diff --git a/Apps/GpsViewer/CHANGELOG.md b/Apps/GpsViewer/CHANGELOG.md
new file mode 100644
index 0000000..c362a3f
--- /dev/null
+++ b/Apps/GpsViewer/CHANGELOG.md
@@ -0,0 +1,33 @@
+# Changelog
+
+## 0.1.0
+
+First release: a GNSS status viewer with four tabs, a sky plot, settings and NMEA recording.
+
+**Screen**
+- Tactility toolbar with close button, title, fix state and menu button. Tabs Position, Sky, Signal, Status.
+- Flat layout with dividers, in the Tactility theme's colours. Night mode in reds on black.
+- Position: coordinates, altitude, course; speed with maximum and average; sunrise and sunset (NOAA algorithm,
+  offline); UTC and local time.
+- Sky: polar plot, north up, rings at 0, 30 and 60 degrees elevation. Shape and colour per system, filled when
+  used. Legend with used / in view per system.
+- Signal: SNR bar per satellite, grouped by system, coloured by strength, outlined when not used. Scrolls
+  sideways.
+- Status: fix type, estimated accuracy (HDOP x 5 m), HDOP / VDOP / PDOP with a quality word, satellites used and
+  in view, time to first fix, receiver model.
+- A message with "Open settings" when there is no receiver or location is off.
+
+**Data**
+- Subscribes to Tactility's location service and reads the first started GPS receiver.
+- Satellites are told apart by the NMEA talker ID when the firmware gives it. Without it, by ID ranges only.
+
+**Recording**
+- Saves the receiver's RMC, GGA, GSA and GSV sentences to `logs/gps-<date>-<time>.nmea`, written every 2 seconds.
+
+**Settings**
+- Units (metric, imperial, nautical), coordinate format (degrees, degrees and minutes, degrees minutes
+  seconds), night mode. Kept in `settings.txt`.
+
+**Input**
+- Keyboard, trackball and touch. Keys 1-4 jump to a tab, `n`, `r`, `s`, `l` and `m` act on night mode,
+  speed reset, settings, recording and the menu.
diff --git a/Apps/GpsViewer/CMakeLists.txt b/Apps/GpsViewer/CMakeLists.txt
new file mode 100644
index 0000000..3b14744
--- /dev/null
+++ b/Apps/GpsViewer/CMakeLists.txt
@@ -0,0 +1,13 @@
+# tactility-cmakelists-version: 1
+cmake_minimum_required(VERSION 3.20)
+
+if (NOT DEFINED ENV{TACTILITY_SDK_PATH})
+    message(FATAL_ERROR "TACTILITY_SDK_PATH environment variable is not set")
+endif()
+
+get_filename_component(TACTILITY_SDK_PATH "$ENV{TACTILITY_SDK_PATH}" ABSOLUTE)
+include("${TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+
+tactility_project_pre(gpsviewer)
+project(gpsviewer)
+tactility_project_post(gpsviewer)
diff --git a/Apps/GpsViewer/LICENSE b/Apps/GpsViewer/LICENSE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/Apps/GpsViewer/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Apps/GpsViewer/README.md b/Apps/GpsViewer/README.md
new file mode 100644
index 0000000..17a862f
--- /dev/null
+++ b/Apps/GpsViewer/README.md
@@ -0,0 +1,132 @@
+# GPS Viewer
+
+A GNSS status app for [Tactility](https://github.com/TactilityProject/Tactility) devices, like the "GPS Test"
+apps on Android. It shows the fix, the satellites in view and used, their signal strength and sky position,
+and the position, speed and time. It is not a map.
+
+Version 0.1.0, app id `tactility.gpsviewer`. Changes are listed in [CHANGELOG.md](CHANGELOG.md). Third-party
+code is listed in [THIRD_PARTY.md](THIRD_PARTY.md).
+
+## Install
+
+Needs Tactility firmware with the GPS API exported to apps. For satellite systems the NMEA talker ID must also
+be in `GpsEvent`. That change is the Tactility PR "gps: add NMEA talker ID to GpsEvent and export GPS API to
+apps", not merged yet.
+
+TODO: Tactility main after that PR, version to be filled in.
+
+Without the talker ID the app still builds and runs. It then groups satellites by NMEA ID ranges only (see
+[Known limits](#known-limits)).
+
+1. Set up a GPS receiver in Tactility's GPS settings and turn on location.
+2. Copy the `.app` file to the SD card, open it in the Files app and confirm "Install".
+3. Start "GPS Viewer" from the app list.
+
+The app subscribes to Tactility's location service, which starts the receiver, and reads the first started
+GPS receiver. It never changes GPS settings. With no receiver it says so on the screen.
+
+## Screen
+
+Tactility's toolbar with the close button, the title, the fix state (for example `3D FIX  3.5m`, prefixed with
+REC while recording, tap it for the Status tab) and the menu button. Below it four tabs: Position, Sky, Signal and Status.
+The content is laid out flat, with thin dividers, in the colours of the Tactility theme (light or dark, and the
+primary colour from Appearance). The monochrome theme drops the colours and keeps the marker shapes.
+
+Colours per system: GPS blue, GLONASS orange, Galileo cyan, BeiDou purple. Night mode draws everything in
+reds on black.
+
+- **Position:** two tiles. Left: latitude and longitude in the chosen format (the font gets smaller when they do
+  not fit), altitude and course over ground (only above 1 m/s). Right: speed, the maximum and average since
+  start or the last reset, and sunrise and sunset for today at the position, computed offline with the NOAA
+  algorithm. Below: UTC date and time from the RMC sentence, local time from Tactility's time zone, and REC
+  while recording.
+- **Sky:** polar plot, north up, rings at 0, 30 and 60 degrees elevation. The marker shape and colour show the
+  system: circle GPS, triangle GLONASS, pentagon Galileo, star BeiDou, square QZSS and SBAS, diamond NavIC and
+  unknown. A filled marker is used in the fix. The legend lists each system with used / in view counts, above
+  it the total.
+- **Signal:** one bar per satellite, height = signal strength (SNR, dB-Hz), grouped by system. Green from 35,
+  orange from 25, grey below. A filled bar is used in the fix, an outlined bar is not. Under each bar are a
+  system marker and the satellite ID. The average SNR of the used satellites is shown above. The bars scroll
+  sideways when there are more than fit.
+- **Status:** fix type, estimated accuracy, HDOP / VDOP / PDOP with a quality word, satellites used / in
+  view, time to first fix and the receiver model. Accuracy is HDOP x 5 m. NMEA has no accuracy value, so the
+  figure is labelled as an estimate. Time to first fix is counted from when the app started listening.
+
+With no receiver, or with location turned off, a message says so, with an "Open settings" button that opens
+Tactility's location settings.
+
+## Controls
+
+| To… | Keyboard | Trackball (keypad mode) | Trackball (pointer mode) | Touch |
+| --- | --- | --- | --- | --- |
+| Next / previous tab | Left / Right arrows, `.` / `,` or Space | Roll left / right | Click the tab name | Swipe left / right, or tap the tab name |
+| Scroll the Signal bars | Enter on the Signal tab, then Left / Right. Enter or Esc to switch tabs again | Click on the Signal tab, then roll left / right. Click to switch tabs again | Click and drag the bars | Drag the bars |
+| Jump to a tab | `1`-`4` | — | Click the tab name | Tap the tab name |
+| Select a tab from the tab row | Move the focus to the tab row, Left / Right, Enter. The Signal tab then scrolls its bars | Roll up to the tab row, roll left / right, click. The Signal tab then scrolls its bars | Click the tab name | Tap the tab name |
+| Open the action menu | Enter (`m` on the Signal tab) | Click (the ⋮ button on the Signal tab) | Click the ⋮ button | Tap the ⋮ button in the toolbar |
+| Move in menus and settings | Up / Down or Left / Right | Roll | Click the row | Tap the row |
+| Select in menus and settings | Enter | Click | Click the row | Tap the row |
+| Close a menu or settings | Esc or Backspace | Select "< Back" | Click "< Back" | Tap "< Back" |
+| Close the app | — | Select the X button | Click the X button | Tap the X button in the toolbar |
+
+An encoder steps through the toolbar buttons, the tabs and the content, and its button selects.
+
+The keys `n` (night mode), `r` (reset max/average speed), `s` (settings) and `l` (start or stop recording)
+work from the keyboard. `m` opens the menu. These actions are also in the menu.
+
+Settings rows change their value on Enter or tap. The menu has: Reset max/average speed,
+Start / Stop recording, Night mode on or off, Settings, Exit and "< Back".
+
+## Settings
+
+- **Units:** Metric (km/h, m), Imperial (mph, ft) or Nautical (kn, m). Nautical uses metres for altitude and
+  accuracy.
+- **Coordinates:** Degrees, Deg. minutes or Deg. min. seconds.
+- **Night mode:** everything in red on black.
+
+Settings are kept in `settings.txt` in the app's user data folder. The file is plain text with one `key=value`
+per line.
+
+## Recording
+
+"Start recording" in the menu (or the `l` key) saves the RMC, GGA, GSA and GSV sentences from the receiver to a file in
+`logs/` in the app's user data folder. The file is named after the GPS date and time, `gps-YYYYMMDD-HHMMSS.nmea`,
+or after the uptime, `gps-up<seconds>.nmea`, when the receiver has no time yet. The toolbar and the Position tab show
+REC while recording. The app writes the file to storage every 2 seconds, so a crash or power loss usually loses
+only the last seconds. Recording stops with "Stop recording" and when the app closes. Without a user data folder
+the app can't record or keep its settings, and the menu says so.
+
+Sentences are written back from the parsed values, with their checksums. Other sentences (VTG, GLL, ...) and
+fields the app does not use are not saved, so a log is not a full capture of the receiver output. The logs are plain NMEA 0183, for use in other tools.
+
+## Testing
+
+Tested on a LilyGO T-Deck with a Quectel L76K on the Grove port (GPS, GLONASS and BeiDou), outdoors and by a
+window. Recording was tested on the device: the log of a live session has the same fix and satellites when
+parsed again. The satellite database, NMEA writer, settings and formatting have host tests.
+
+## Known limits
+
+- Without the NMEA talker ID (see [Install](#install)), Galileo and BeiDou satellites are shown as GPS.
+- NMEA has no accuracy value. The accuracy shown is HDOP x 5 m, an estimate only.
+- Only tested on the LilyGO T-Deck, and with one receiver (L76K).
+- Tactility starts the receiver when the app opens and stops it when the app closes. With "Auto-detect" in the
+  GPS settings, the driver first tries other receiver types, which took about 4.4 s for the L76K. Choosing the
+  model in the GPS settings skips that.
+- Fonts are Tactility's three text sizes: there is no bold font.
+
+## Building
+
+Needs ESP-IDF 6.1 and the Tactility SDK matching the firmware on the device. Set `TACTILITY_SDK_PATH` to the
+SDK folder, then:
+
+```
+python <Tactility>/tt.py app build
+python <Tactility>/tt.py app install --host <device ip>
+python <Tactility>/tt.py app run --host <device ip>
+```
+
+## Licence
+
+GPL-3.0-or-later, the same as Tactility; see [LICENSE](LICENSE). Third-party code is listed in
+[THIRD_PARTY.md](THIRD_PARTY.md).
diff --git a/Apps/GpsViewer/THIRD_PARTY.md b/Apps/GpsViewer/THIRD_PARTY.md
new file mode 100644
index 0000000..a92fd50
--- /dev/null
+++ b/Apps/GpsViewer/THIRD_PARTY.md
@@ -0,0 +1,5 @@
+# Third-party code
+
+| Component | Where | Licence | Notes |
+|---|---|---|---|
+| NOAA solar calculator equations | `main/Source/core/SunTimes.cpp` | Public domain (US government work) | From the NOAA Global Monitoring Laboratory solar calculator. Used for sunrise and sunset. |
diff --git a/Apps/GpsViewer/main/CMakeLists.txt b/Apps/GpsViewer/main/CMakeLists.txt
new file mode 100644
index 0000000..7b384a3
--- /dev/null
+++ b/Apps/GpsViewer/main/CMakeLists.txt
@@ -0,0 +1,7 @@
+include("$ENV{TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+
+file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
+tactility_component_register(
+    SRCS ${SOURCE_FILES}
+    REQUIRES gps-module location-module
+)
diff --git a/Apps/GpsViewer/main/Source/app/AppContext.h b/Apps/GpsViewer/main/Source/app/AppContext.h
new file mode 100644
index 0000000..cf7ac77
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/AppContext.h
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "../core/GnssModel.h"
+#include "../core/Settings.h"
+
+#include <app/instance.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+#include <atomic>
+#include <cstdint>
+
+namespace gpsviewer {
+
+constexpr const char* APP_ID = "tactility.gpsviewer";
+constexpr int PATH_LENGTH = 192;
+
+enum class SourceStatus : uint8_t {
+    NoReceiver,
+    LocationOff,
+    ReceiverStarting,
+    Receiving,
+    ReceiverLost,
+};
+
+// Bits for AppContext::requests, set by the UI and handled by the app task
+enum Request : uint32_t {
+    REQUEST_SAVE_SETTINGS = 1U << 0,
+    REQUEST_RESET_SPEED = 1U << 1,
+    // Opens Tactility's location settings, where GPS receivers are set up and location is turned on
+    REQUEST_OPEN_LOCATION_SETTINGS = 1U << 4,
+};
+
+struct AppContext;
+
+// LVGL thread only. Defined in Ui.cpp.
+struct UiState;
+
+struct AppContext {
+    AppInstanceId appInstanceId = 0;
+    char dataDirectory[PATH_LENGTH] = "";
+
+    // Guards everything up to the end of this block, between the app task and the LVGL thread
+    SemaphoreHandle_t mutex = nullptr;
+    GnssModel model;
+    Settings settings;
+    SourceStatus status = SourceStatus::NoReceiver;
+    // Counts receiver connections. Events from an earlier connection are dropped.
+    uint32_t session = 0;
+    char receiverName[32] = "";
+    bool recording = false;
+    char recordingName[40] = "";
+    uint32_t recordedLines = 0;
+
+    std::atomic<uint32_t> requests {0};
+    // Start/stop presses not handled yet. Each one toggles recording, so two quick presses cancel out.
+    std::atomic<uint32_t> recordingToggles {0};
+
+    // LVGL thread only
+    UiState* ui = nullptr;
+};
+
+class ContextLock {
+public:
+    explicit ContextLock(AppContext& context) : context(context) { xSemaphoreTake(context.mutex, portMAX_DELAY); }
+    ~ContextLock() { xSemaphoreGive(context.mutex); }
+    ContextLock(const ContextLock&) = delete;
+    ContextLock& operator=(const ContextLock&) = delete;
+
+private:
+    AppContext& context;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Main.cpp b/Apps/GpsViewer/main/Source/app/Main.cpp
new file mode 100644
index 0000000..d95073f
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Main.cpp
@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "AppContext.h"
+#include "Sources.h"
+#include "Ui.h"
+
+#include <app/event.h>
+#include <app/paths.h>
+#include <app/scheduler.h>
+#include <app/start.h>
+#include <lvgl_window_manager/window_manager.h>
+#include <tactility/Memory.hpp>
+#include <tactility/check.h>
+#include <tactility/time.h>
+
+#include <freertos/task.h>
+#include <sys/stat.h>
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+// The app task waits this long for a GPS event before it looks at app events and requests
+constexpr uint32_t POLL_MS = 50;
+
+void settingsPath(const AppContext& context, char* out, size_t outSize) {
+    snprintf(out, outSize, "%s/settings.txt", context.dataDirectory);
+}
+
+// Without a data folder the settings stay at their defaults and aren't saved
+Settings loadSettings(const AppContext& context) {
+    if (context.dataDirectory[0] == '\0') {
+        return parseSettings("");
+    }
+    char path[PATH_LENGTH + 16];
+    settingsPath(context, path, sizeof(path));
+    char text[256] = "";
+    FILE* file = fopen(path, "r");
+    if (file != nullptr) {
+        const size_t length = fread(text, 1, sizeof(text) - 1, file);
+        text[length] = '\0';
+        fclose(file);
+    }
+    return parseSettings(text);
+}
+
+void saveSettings(const AppContext& context, const Settings& settings) {
+    if (context.dataDirectory[0] == '\0') {
+        return;
+    }
+    char text[256];
+    const size_t length = serializeSettings(settings, text, sizeof(text));
+    char path[PATH_LENGTH + 16];
+    settingsPath(context, path, sizeof(path));
+    FILE* file = fopen(path, "w");
+    if (file != nullptr) {
+        fwrite(text, 1, length, file);
+        fclose(file);
+    }
+}
+
+// On the heap, as the recorder's write buffer alone is larger than what the app task's stack can spare
+struct Sources {
+    GpsSource gps;
+    Recorder recorder;
+};
+
+void run(AppContext& context, Sources& sources) {
+    GpsSource& gps = sources.gps;
+    Recorder& recorder = sources.recorder;
+    struct TaskEventGroup eventGroup {};
+    task_event_group_construct(&eventGroup);
+    struct AppEventSubscription appEvents {};
+    check(app_event_subscribe(&appEvents, &eventGroup) == ERROR_NONE);
+
+    gps.start(context, &eventGroup);
+
+    WindowId window = window_manager_create_ext(context.appInstanceId, uiCreateWidgets, uiDestroyWidgets, &context);
+
+    bool close = false;
+    while (!close) {
+        gps.poll(context, POLL_MS, recorder);
+
+        struct AppEvent event;
+        while (app_event_poll(&appEvents, &event) == ERROR_NONE) {
+            if (event.type == APP_EVENT_CLOSE) {
+                close = true;
+            }
+        }
+
+        {
+            ContextLock lock(context);
+            context.recording = recorder.isRecording();
+            context.recordedLines = recorder.lineCount();
+            snprintf(context.recordingName, sizeof(context.recordingName), "%s", recorder.fileName());
+        }
+        const uint32_t requests = context.requests.exchange(0);
+        if ((requests & REQUEST_SAVE_SETTINGS) != 0) {
+            Settings settings;
+            {
+                ContextLock lock(context);
+                settings = context.settings;
+            }
+            saveSettings(context, settings);
+        }
+        if ((context.recordingToggles.exchange(0) % 2) != 0) {
+            if (recorder.isRecording()) {
+                recorder.stop();
+            } else {
+                UtcDateTime utc;
+                {
+                    ContextLock lock(context);
+                    utc = context.model.utc();
+                }
+                recorder.start(context.dataDirectory, utc, get_millis());
+            }
+        }
+        if ((requests & REQUEST_OPEN_LOCATION_SETTINGS) != 0) {
+            struct AppStartContext start {};
+            if (app_start_context_from_id("tactility.locationsettings", &start) == ERROR_NONE) {
+                AppInstanceId instanceId;
+                app_start_with_context(&start, &instanceId);
+            }
+        }
+        if ((requests & REQUEST_RESET_SPEED) != 0) {
+            ContextLock lock(context);
+            context.model.resetSpeedStats();
+        }
+    }
+
+    window_manager_remove(window);
+    recorder.stop();
+    gps.stop();
+    check(app_event_unsubscribe(&appEvents) == ERROR_NONE);
+    task_event_group_destruct(&eventGroup);
+}
+
+} // namespace
+
+} // namespace gpsviewer
+
+extern "C" int main(int argc, char* argv[]) {
+    (void)argc;
+    (void)argv;
+    using namespace gpsviewer;
+
+    // The app state is large, so it goes to external memory when there is some
+    auto* context = tt::newObject<AppContext>();
+    if (context == nullptr) {
+        return 0;
+    }
+    context->appInstanceId = app_scheduler_current_app_id();
+    // Without a data folder the app still shows the receiver, but keeps no settings and can't record.
+    // The menu says so in place of "Start recording".
+    if (app_paths_get_user_data_directory(APP_ID, context->dataDirectory, sizeof(context->dataDirectory)) == ERROR_NONE) {
+        mkdir(context->dataDirectory, 0777);
+    } else {
+        context->dataDirectory[0] = '\0';
+    }
+    context->mutex = xSemaphoreCreateMutex();
+    context->ui = uiAllocate(*context);
+    if (context->mutex != nullptr && context->ui != nullptr) {
+        context->settings = loadSettings(*context);
+        context->model.reset(get_millis());
+        auto* sources = tt::newObject<Sources>();
+        if (sources != nullptr) {
+            run(*context, *sources);
+            tt::deleteObject(sources);
+        }
+    }
+    uiFree(context->ui);
+    if (context->mutex != nullptr) {
+        vSemaphoreDelete(context->mutex);
+    }
+    tt::deleteObject(context);
+    return 0;
+}
diff --git a/Apps/GpsViewer/main/Source/app/MessageCard.cpp b/Apps/GpsViewer/main/Source/app/MessageCard.cpp
new file mode 100644
index 0000000..67b57ba
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/MessageCard.cpp
@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <lvgl/devices/keyboard.h>
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+bool hasMessage(SourceStatus status) {
+    switch (status) {
+        case SourceStatus::NoReceiver:
+        case SourceStatus::LocationOff:
+        case SourceStatus::ReceiverStarting:
+        case SourceStatus::ReceiverLost:
+            return true;
+        default:
+            return false;
+    }
+}
+
+bool hasSettingsButton(SourceStatus status) {
+    return status == SourceStatus::NoReceiver || status == SourceStatus::LocationOff ||
+           status == SourceStatus::ReceiverStarting;
+}
+
+} // namespace
+
+void MessageCard::create(lv_obj_t* parent, const Theme& theme, lv_event_cb_t onSettings, lv_event_cb_t onKey, void* userData) {
+    card = createSection(parent);
+    lv_obj_set_width(card, LV_PCT(92));
+    lv_obj_set_height(card, LV_SIZE_CONTENT);
+    lv_obj_center(card);
+    lv_obj_set_style_pad_all(card, LV_DPX(8), LV_PART_MAIN);
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(card, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_row(card, LV_DPX(5), LV_PART_MAIN);
+
+    createIcon(card, IconKind::Alert, LV_DPX(28), theme.warning, theme.background);
+    titleLabel = createLabel(card, FONT_SIZE_LARGE, theme.text);
+    lv_obj_set_width(titleLabel, LV_PCT(100));
+    lv_obj_set_style_text_align(titleLabel, LV_TEXT_ALIGN_CENTER, LV_PART_MAIN);
+    helpLabel = createLabel(card, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_long_mode(helpLabel, LV_LABEL_LONG_WRAP);
+    lv_obj_set_width(helpLabel, LV_PCT(100));
+    lv_obj_set_style_text_align(helpLabel, LV_TEXT_ALIGN_CENTER, LV_PART_MAIN);
+
+    // The theme styles the button, except in night mode
+    button = lv_button_create(card);
+    lv_obj_t* label = lv_label_create(button);
+    lv_label_set_text(label, "Open settings");
+    if (theme.night) {
+        lv_obj_set_style_bg_color(button, theme.accent, LV_PART_MAIN);
+        lv_obj_set_style_text_color(label, theme.background, LV_PART_MAIN);
+        lv_obj_set_style_outline_color(button, theme.text, LV_STATE_FOCUS_KEY);
+    }
+    lv_obj_add_event_cb(button, onSettings, LV_EVENT_CLICKED, userData);
+    lv_obj_add_event_cb(button, onKey, LV_EVENT_KEY, userData);
+    lv_obj_add_flag(card, LV_OBJ_FLAG_HIDDEN);
+    visible = false;
+    buttonInGroup = lv_group_get_default() != nullptr;
+    // Only in the group while there is a button to use
+    if (buttonInGroup) {
+        lv_group_remove_obj(button);
+        buttonInGroup = false;
+    }
+}
+
+void MessageCard::clear() {
+    card = nullptr;
+    titleLabel = nullptr;
+    helpLabel = nullptr;
+    button = nullptr;
+    visible = false;
+    buttonInGroup = false;
+}
+
+bool MessageCard::update(SourceStatus status, const char* dataDirectory) {
+    if (card == nullptr) {
+        return false;
+    }
+    const bool show = hasMessage(status);
+    if (!show) {
+        if (buttonInGroup && button != nullptr) {
+            lv_group_remove_obj(button);
+            buttonInGroup = false;
+        }
+        setHidden(card, true);
+        visible = false;
+        return false;
+    }
+    char help[PATH_LENGTH + 40];
+    const char* title = "";
+    help[0] = '\0';
+    switch (status) {
+        case SourceStatus::NoReceiver:
+            title = "No GPS receiver";
+            snprintf(help, sizeof(help), "Set one up in Tactility's GPS settings.");
+            break;
+        case SourceStatus::LocationOff:
+            title = "Location is off";
+            snprintf(help, sizeof(help), "Turn it on in Tactility's location settings.");
+            break;
+        case SourceStatus::ReceiverStarting:
+            title = "Starting GPS receiver...";
+            snprintf(help, sizeof(help), "If this takes long, check the receiver in the GPS settings.");
+            break;
+        case SourceStatus::ReceiverLost:
+            title = "GPS receiver stopped";
+            snprintf(help, sizeof(help), "Waiting for it to come back...");
+            break;
+        default:
+            break;
+    }
+    setLabelText(titleLabel, title);
+    setLabelText(helpLabel, help);
+
+    const bool withButton = hasSettingsButton(status);
+    setHidden(button, !withButton);
+    // The app's group, also while a menu overlay has its own group
+    lv_group_t* group = lvgl_keyboard_get_app_group();
+    if (button != nullptr && group != nullptr) {
+        if (withButton && !buttonInGroup) {
+            lv_group_add_obj(group, button);
+            buttonInGroup = true;
+        } else if (!withButton && buttonInGroup) {
+            lv_group_remove_obj(button);
+            buttonInGroup = false;
+        }
+    }
+    setHidden(card, false);
+    visible = true;
+    return true;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/PositionTab.cpp b/Apps/GpsViewer/main/Source/app/PositionTab.cpp
new file mode 100644
index 0000000..e861657
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/PositionTab.cpp
@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+#include "../core/SunTimes.h"
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+
+namespace gpsviewer {
+
+namespace {
+
+void localClock(long long epoch, int& hour, int& minute) {
+    time_t t = static_cast<time_t>(epoch);
+    struct tm local;
+    localtime_r(&t, &local);
+    hour = local.tm_hour;
+    minute = local.tm_min;
+}
+
+const char* compass(float degrees) {
+    static const char names[8][3] = {"N", "NE", "E", "SE", "S", "SW", "W", "NW"};
+    float d = degrees;
+    while (d < 0) {
+        d += 360.0f;
+    }
+    const int index = static_cast<int>((d + 22.5f) / 45.0f) % 8;
+    return names[index];
+}
+
+lv_obj_t* createRow(lv_obj_t* parent, int gap) {
+    lv_obj_t* row = createBox(parent);
+    lv_obj_set_size(row, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_column(row, gap, LV_PART_MAIN);
+    return row;
+}
+
+lv_obj_t* createColumn(lv_obj_t* parent) {
+    lv_obj_t* card = createSection(parent);
+    lv_obj_set_height(card, LV_PCT(100));
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(card, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_row(card, LV_DPX(2), LV_PART_MAIN);
+    return card;
+}
+
+lv_obj_t* createSpacer(lv_obj_t* parent) {
+    lv_obj_t* spacer = createBox(parent);
+    lv_obj_set_size(spacer, 1, 1);
+    lv_obj_set_flex_grow(spacer, 1);
+    return spacer;
+}
+
+} // namespace
+
+void PositionTab::create(lv_obj_t* parent, const Theme& theme) {
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_row(parent, LV_DPX(2), LV_PART_MAIN);
+
+    lv_obj_t* grid = createBox(parent);
+    lv_obj_set_width(grid, LV_PCT(100));
+    lv_obj_set_flex_grow(grid, 1);
+    lv_obj_set_flex_flow(grid, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_pad_column(grid, LV_DPX(6), LV_PART_MAIN);
+
+    // Left tile: coordinates, altitude, course
+    lv_obj_t* left = createColumn(grid);
+    lv_obj_set_width(left, LV_PCT(56));
+    setDivider(left, theme, LV_BORDER_SIDE_RIGHT);
+    createCaption(left, theme, "Coordinates");
+    latitudeLabel = createLabel(left, FONT_SIZE_LARGE, theme.text);
+    longitudeLabel = createLabel(left, FONT_SIZE_LARGE, theme.text);
+    createSpacer(left);
+    altitudeLabel = createLabel(left, FONT_SIZE_DEFAULT, theme.text);
+    courseLabel = createLabel(left, FONT_SIZE_SMALL, theme.dim);
+
+    // Right tile: speed, statistics, sunrise and sunset
+    lv_obj_t* right = createColumn(grid);
+    lv_obj_set_flex_grow(right, 1);
+    createCaption(right, theme, "Speed");
+    lv_obj_t* speedRow = createRow(right, LV_DPX(4));
+    lv_obj_set_flex_align(speedRow, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END);
+    speedLabel = createLabel(speedRow, FONT_SIZE_LARGE, theme.accent);
+    speedUnitLabel = createLabel(speedRow, FONT_SIZE_SMALL, theme.dim);
+    speedStatsLabel = createLabel(right, FONT_SIZE_SMALL, theme.dim);
+    createSpacer(right);
+    const int icon = LV_DPX(12);
+    lv_obj_t* sunRow = createRow(right, LV_DPX(3));
+    createIcon(sunRow, IconKind::Sun, icon, theme.warning, theme.background);
+    riseLabel = createLabel(sunRow, FONT_SIZE_SMALL, theme.text);
+    setRow = createRow(right, LV_DPX(3));
+    createIcon(setRow, IconKind::Moon, icon, theme.dim, theme.background);
+    setLabel = createLabel(setRow, FONT_SIZE_SMALL, theme.text);
+
+    // Bottom status bar: UTC and local time, REC
+    lv_obj_t* bar = createRow(parent, LV_DPX(6));
+    setDivider(bar, theme, LV_BORDER_SIDE_TOP);
+    lv_obj_set_style_pad_top(bar, LV_DPX(3), LV_PART_MAIN);
+    lv_obj_set_style_pad_hor(bar, LV_DPX(4), LV_PART_MAIN);
+    timeLabel = createLabel(bar, FONT_SIZE_SMALL, theme.dim);
+    lv_obj_set_flex_grow(timeLabel, 1);
+    recPill = createTag(bar, "REC", theme.warning);
+    lv_obj_add_flag(recPill, LV_OBJ_FLAG_HIDDEN);
+
+    fitWidth = -1;
+    sunYear = 0;
+    sunMonth = 0;
+    sunDay = 0;
+    sunLatitude = 1000;
+    sunLongitude = 1000;
+    riseText[0] = '\0';
+    setText[0] = '\0';
+}
+
+void PositionTab::update(const TabView& view) {
+    if (latitudeLabel == nullptr || timeLabel == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+    const Units units = view.settings.units;
+    char text[96];
+    char part[40];
+    const int columnWidth = lv_obj_get_content_width(lv_obj_get_parent(latitudeLabel));
+    // Right after a rebuild the layout may not have run yet. Pick the font again once the width is known.
+    if (columnWidth != fitWidth) {
+        fitWidth = columnWidth;
+        lv_label_set_text(latitudeLabel, "");
+        lv_label_set_text(longitudeLabel, "");
+    }
+
+    if (s.hasPosition) {
+        formatCoordinate(s.latitude, true, view.settings.coordinateFormat, part, sizeof(part));
+        setFittedText(latitudeLabel, part, columnWidth);
+        formatCoordinate(s.longitude, false, view.settings.coordinateFormat, part, sizeof(part));
+        setFittedText(longitudeLabel, part, columnWidth);
+    } else {
+        setFittedText(latitudeLabel, "Lat --", columnWidth);
+        setFittedText(longitudeLabel, "Lon --", columnWidth);
+    }
+
+    if (s.hasAltitude) {
+        formatAltitude(s.altitudeMeters, units, part, sizeof(part));
+        snprintf(text, sizeof(text), "Alt %s MSL", part);
+    } else {
+        snprintf(text, sizeof(text), "Alt --");
+    }
+    setLabelText(altitudeLabel, text);
+    if (!std::isnan(s.courseDegrees)) {
+        snprintf(text, sizeof(text), "Course %d\xC2\xB0 %s", static_cast<int>(s.courseDegrees + 0.5f) % 360,
+                 compass(s.courseDegrees));
+        setLabelText(courseLabel, text);
+        setHidden(courseLabel, false);
+    } else {
+        setHidden(courseLabel, true);
+    }
+
+    if (s.hasSpeed) {
+        formatSpeed(s.speedMps, units, part, sizeof(part));
+    } else {
+        snprintf(part, sizeof(part), "--");
+    }
+    setLabelText(speedLabel, part);
+    setLabelText(speedUnitLabel, speedUnit(units));
+    char maxText[16];
+    char avgText[16];
+    formatSpeed(s.maxSpeedMps, units, maxText, sizeof(maxText));
+    formatSpeed(s.averageSpeedMps, units, avgText, sizeof(avgText));
+    // On one line when it fits the column, otherwise on two, so large fonts keep both values
+    snprintf(text, sizeof(text), "Max %s | Avg %s", maxText, avgText);
+    const int statsWidth = lv_obj_get_content_width(lv_obj_get_parent(speedStatsLabel));
+    if (measureTextWidth(text, lvgl_get_text_font(FONT_SIZE_SMALL)) > statsWidth) {
+        snprintf(text, sizeof(text), "Max %s\nAvg %s", maxText, avgText);
+    }
+    setLabelText(speedStatsLabel, text);
+
+    setHidden(recPill, !view.recording);
+
+    if (s.utc.valid) {
+        const long long epoch = utcToEpoch(s.utc.year, s.utc.month, s.utc.day, s.utc.hour, s.utc.minute, s.utc.second);
+        int hour;
+        int minute;
+        localClock(epoch, hour, minute);
+        int length = snprintf(text, sizeof(text), "%04d-%02d-%02d %02d:%02d UTC", s.utc.year, s.utc.month, s.utc.day,
+                              s.utc.hour, s.utc.minute);
+        if ((hour != s.utc.hour || minute != s.utc.minute) && length > 0 && length < static_cast<int>(sizeof(text))) {
+            snprintf(text + length, sizeof(text) - static_cast<size_t>(length), "  %02d:%02d local", hour, minute);
+        }
+        setLabelText(timeLabel, text);
+    } else {
+        setLabelText(timeLabel, "Time --");
+    }
+
+    if (!s.hasPosition || !s.utc.valid) {
+        setLabelText(riseLabel, "Sun --");
+        setHidden(setRow, true);
+        riseText[0] = '\0';
+        sunYear = 0;
+        return;
+    }
+    const bool sameDate = s.utc.year == sunYear && s.utc.month == sunMonth && s.utc.day == sunDay;
+    const bool samePlace = std::fabs(s.latitude - sunLatitude) <= 0.01 && std::fabs(s.longitude - sunLongitude) <= 0.01;
+    if (!sameDate || !samePlace || riseText[0] == '\0') {
+        sunYear = s.utc.year;
+        sunMonth = s.utc.month;
+        sunDay = s.utc.day;
+        sunLatitude = s.latitude;
+        sunLongitude = s.longitude;
+        const SunTimes sun = computeSunTimes(sunYear, sunMonth, sunDay, sunLatitude, sunLongitude);
+        if (sun.day == SunDay::PolarDay) {
+            snprintf(riseText, sizeof(riseText), "Polar day");
+            setText[0] = '\0';
+        } else if (sun.day == SunDay::PolarNight) {
+            snprintf(riseText, sizeof(riseText), "Polar night");
+            setText[0] = '\0';
+        } else {
+            const long long base = utcToEpoch(sunYear, sunMonth, sunDay, 0, 0, 0);
+            int riseHour;
+            int riseMinute;
+            int setHour;
+            int setMinute;
+            localClock(base + static_cast<long long>(std::floor(sun.sunriseUtcMinutes * 60.0 + 0.5)), riseHour, riseMinute);
+            localClock(base + static_cast<long long>(std::floor(sun.sunsetUtcMinutes * 60.0 + 0.5)), setHour, setMinute);
+            snprintf(riseText, sizeof(riseText), "Rise %02d:%02d", riseHour, riseMinute);
+            snprintf(setText, sizeof(setText), "Set %02d:%02d", setHour, setMinute);
+        }
+    }
+    setLabelText(riseLabel, riseText);
+    setLabelText(setLabel, setText);
+    setHidden(setRow, setText[0] == '\0');
+}
+
+void PositionTab::clear() {
+    latitudeLabel = nullptr;
+    longitudeLabel = nullptr;
+    altitudeLabel = nullptr;
+    courseLabel = nullptr;
+    speedLabel = nullptr;
+    speedUnitLabel = nullptr;
+    speedStatsLabel = nullptr;
+    riseLabel = nullptr;
+    setRow = nullptr;
+    setLabel = nullptr;
+    timeLabel = nullptr;
+    recPill = nullptr;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Recorder.cpp b/Apps/GpsViewer/main/Source/app/Recorder.cpp
new file mode 100644
index 0000000..78f0720
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Recorder.cpp
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Recorder.h"
+#include "AppContext.h"
+
+#include "../core/NmeaWriter.h"
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// Fewer, larger writes keep the SD card and the shared SPI bus quiet
+constexpr uint32_t FLUSH_INTERVAL_MS = 2000;
+constexpr size_t MAX_LINE = 128;
+
+bool endsWith(const char* text, const char* suffix) {
+    const size_t textLength = strlen(text);
+    const size_t suffixLength = strlen(suffix);
+    return textLength >= suffixLength && strcmp(text + textLength - suffixLength, suffix) == 0;
+}
+
+} // namespace
+
+bool Recorder::start(const char* dataDirectory, const UtcDateTime& utc, uint32_t nowMs) {
+    stop();
+    if (dataDirectory[0] == '\0') {
+        return false;
+    }
+    char folder[PATH_LENGTH + 8];
+    snprintf(folder, sizeof(folder), "%s/logs", dataDirectory);
+    mkdir(folder, 0777);
+    if (utc.valid) {
+        snprintf(name, sizeof(name), "gps-%04d%02d%02d-%02d%02d%02d.nmea", utc.year, utc.month, utc.day, utc.hour, utc.minute, utc.second);
+    } else {
+        snprintf(name, sizeof(name), "gps-up%lu.nmea", static_cast<unsigned long>(nowMs / 1000));
+    }
+    char path[PATH_LENGTH + 48];
+    snprintf(path, sizeof(path), "%s/%s", folder, name);
+    file = fopen(path, "w");
+    used = 0;
+    lines = 0;
+    flushedAtMs = nowMs;
+    if (file == nullptr) {
+        name[0] = '\0';
+        return false;
+    }
+    return true;
+}
+
+void Recorder::flush() {
+    if (file != nullptr && used > 0) {
+        fwrite(buffer, 1, used, file);
+        fflush(file);
+        // FAT only commits the data and the file size on sync, so a crash or power loss keeps the log
+        fsync(fileno(file));
+    }
+    used = 0;
+}
+
+void Recorder::stop() {
+    if (file == nullptr) {
+        return;
+    }
+    flush();
+    fclose(file);
+    file = nullptr;
+}
+
+void Recorder::write(const GnssEvent& event, uint32_t nowMs) {
+    if (file == nullptr) {
+        return;
+    }
+    if (sizeof(buffer) - used < MAX_LINE) {
+        flush();
+    }
+    const size_t length = formatNmeaLine(event, buffer + used, sizeof(buffer) - used);
+    if (length > 0) {
+        used += length;
+        lines++;
+    }
+    if (nowMs - flushedAtMs >= FLUSH_INTERVAL_MS) {
+        flush();
+        flushedAtMs = nowMs;
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Recorder.h b/Apps/GpsViewer/main/Source/app/Recorder.h
new file mode 100644
index 0000000..e9b861d
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Recorder.h
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "../core/GnssModel.h"
+
+#include <cstdint>
+#include <cstdio>
+
+namespace gpsviewer {
+
+// Writes received GPS events as an NMEA log. App task only.
+class Recorder {
+public:
+    // Creates <dataDirectory>/logs/gps-<UTC date and time>.nmea, or gps-up<uptime>.nmea without a valid time
+    bool start(const char* dataDirectory, const UtcDateTime& utc, uint32_t nowMs);
+    void stop();
+    void write(const GnssEvent& event, uint32_t nowMs);
+    bool isRecording() const { return file != nullptr; }
+    uint32_t lineCount() const { return lines; }
+    const char* fileName() const { return name; }
+
+private:
+    void flush();
+
+    FILE* file = nullptr;
+    char name[40] = "";
+    char buffer[4096] = "";
+    size_t used = 0;
+    uint32_t lines = 0;
+    uint32_t flushedAtMs = 0;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/SignalTab.cpp b/Apps/GpsViewer/main/Source/app/SignalTab.cpp
new file mode 100644
index 0000000..f0aabfe
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/SignalTab.cpp
@@ -0,0 +1,337 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr int BAR_WIDTH = 14;
+constexpr int BAR_SPACING = 4;
+constexpr int BAR_PITCH = BAR_WIDTH + BAR_SPACING;
+// Extra space between two constellation groups
+constexpr int GROUP_GAP = 8;
+// Left strip with the scale labels
+constexpr int GUTTER = 20;
+constexpr int PAGE_BARS = 4;
+constexpr int MAX_SNR = 50;
+
+int systemRank(GnssSystem system) {
+    return system == GnssSystem::Unknown ? 99 : static_cast<int>(system);
+}
+
+bool before(const Satellite& a, const Satellite& b) {
+    if (a.system != b.system) {
+        return systemRank(a.system) < systemRank(b.system);
+    }
+    return a.id < b.id;
+}
+
+bool sameDrawn(const Satellite& a, const Satellite& b) {
+    return a.system == b.system && a.id == b.id && a.snr == b.snr && a.used == b.used;
+}
+
+} // namespace
+
+void SignalTab::create(lv_obj_t* parent, const Theme& themeIn) {
+    theme = &themeIn;
+    lv_obj_t* card = createSection(parent);
+    lv_obj_set_size(card, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_style_pad_all(card, LV_DPX(4), LV_PART_MAIN);
+    lv_obj_set_flex_flow(card, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(card, LV_DPX(2), LV_PART_MAIN);
+
+    summaryLabel = createLabel(card, FONT_SIZE_SMALL, themeIn.text);
+    lv_obj_set_width(summaryLabel, LV_PCT(100));
+
+    bars = createBox(card);
+    lv_obj_set_width(bars, LV_PCT(100));
+    lv_obj_set_flex_grow(bars, 1);
+    // The bars are dragged, so the tab swipe must not fire on top of that
+    lv_obj_remove_flag(bars, LV_OBJ_FLAG_GESTURE_BUBBLE);
+    lv_obj_add_flag(bars, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_add_event_cb(bars, onDraw, LV_EVENT_DRAW_MAIN, this);
+    lv_obj_add_event_cb(bars, onPress, LV_EVENT_PRESSED, this);
+    lv_obj_add_event_cb(bars, onPress, LV_EVENT_PRESSING, this);
+    lv_obj_add_event_cb(bars, onPress, LV_EVENT_RELEASED, this);
+    dragging = false;
+    count = 0;
+    totalWidth = 0;
+}
+
+int SignalTab::contentWidth() const {
+    return lv_obj_get_width(bars) - GUTTER;
+}
+
+int SignalTab::maxScroll() const {
+    const int overflow = totalWidth - contentWidth();
+    return overflow > 0 ? overflow : 0;
+}
+
+void SignalTab::update(const TabView& view) {
+    if (summaryLabel == nullptr || bars == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+
+    Satellite sorted[SatelliteDb::MAX_SATELLITES];
+    int n = s.satelliteCount;
+    if (n > SatelliteDb::MAX_SATELLITES) {
+        n = SatelliteDb::MAX_SATELLITES;
+    }
+    if (n < 0) {
+        n = 0;
+    }
+    for (int i = 0; i < n; i++) {
+        const Satellite value = s.satellites[i];
+        int j = i;
+        while (j > 0 && before(value, sorted[j - 1])) {
+            sorted[j] = sorted[j - 1];
+            j--;
+        }
+        sorted[j] = value;
+    }
+
+    bool changed = n != count;
+    for (int i = 0; !changed && i < n; i++) {
+        changed = !sameDrawn(sorted[i], satellites[i]);
+    }
+    if (changed) {
+        count = n;
+        int x = 0;
+        for (int i = 0; i < n; i++) {
+            satellites[i] = sorted[i];
+            if (i > 0) {
+                x += BAR_PITCH + (satellites[i].system != satellites[i - 1].system ? GROUP_GAP : 0);
+            }
+            offsets[i] = static_cast<int16_t>(x);
+        }
+        totalWidth = n > 0 ? x + BAR_WIDTH : 0;
+        const int limit = maxScroll();
+        if (scrollPx > limit) {
+            scrollPx = limit;
+        }
+        lv_obj_invalidate(bars);
+    }
+
+    int sum = 0;
+    int used = 0;
+    for (int i = 0; i < n; i++) {
+        if (sorted[i].used && sorted[i].snr > 0) {
+            sum += sorted[i].snr;
+            used++;
+        }
+    }
+    char text[96];
+    if (used > 0) {
+        snprintf(text, sizeof(text), "Avg SNR (used) %d dB-Hz   %d used / %d in view", (sum + used / 2) / used,
+                 s.satellitesUsed, s.satellitesInView);
+    } else {
+        snprintf(text, sizeof(text), "Avg SNR (used) --   %d used / %d in view", s.satellitesUsed, s.satellitesInView);
+    }
+    setLabelText(summaryLabel, text);
+}
+
+void SignalTab::clear() {
+    summaryLabel = nullptr;
+    bars = nullptr;
+    theme = nullptr;
+    dragging = false;
+}
+
+bool SignalTab::scroll(int direction) {
+    if (bars == nullptr) {
+        return false;
+    }
+    const int limit = maxScroll();
+    if (direction > 0 && scrollPx < limit) {
+        scrollPx += PAGE_BARS * BAR_PITCH;
+        if (scrollPx > limit) {
+            scrollPx = limit;
+        }
+        lv_obj_invalidate(bars);
+        return true;
+    }
+    if (direction < 0 && scrollPx > 0) {
+        scrollPx -= PAGE_BARS * BAR_PITCH;
+        if (scrollPx < 0) {
+            scrollPx = 0;
+        }
+        lv_obj_invalidate(bars);
+        return true;
+    }
+    return false;
+}
+
+void SignalTab::onPress(lv_event_t* event) {
+    auto* self = static_cast<SignalTab*>(lv_event_get_user_data(event));
+    if (self->bars == nullptr) {
+        return;
+    }
+    const lv_event_code_t code = lv_event_get_code(event);
+    if (code == LV_EVENT_RELEASED) {
+        self->dragging = false;
+        return;
+    }
+    lv_indev_t* indev = lv_indev_active();
+    if (indev == nullptr) {
+        return;
+    }
+    lv_point_t p;
+    lv_indev_get_point(indev, &p);
+    if (code == LV_EVENT_PRESSED) {
+        self->dragging = true;
+        self->dragStartX = p.x;
+        self->dragStartScroll = self->scrollPx;
+        return;
+    }
+    if (!self->dragging) {
+        return;
+    }
+    int next = self->dragStartScroll - (p.x - self->dragStartX);
+    const int limit = self->maxScroll();
+    if (next < 0) {
+        next = 0;
+    }
+    if (next > limit) {
+        next = limit;
+    }
+    if (next != self->scrollPx) {
+        self->scrollPx = next;
+        lv_obj_invalidate(self->bars);
+    }
+}
+
+void SignalTab::onDraw(lv_event_t* event) {
+    auto* self = static_cast<SignalTab*>(lv_event_get_user_data(event));
+    if (self->bars == nullptr || self->theme == nullptr) {
+        return;
+    }
+    const Theme& theme = *self->theme;
+    lv_layer_t* layer = lv_event_get_layer(event);
+    lv_area_t area;
+    lv_obj_get_coords(self->bars, &area);
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    const int lineHeight = lv_font_get_line_height(font);
+
+    if (self->count == 0) {
+        lv_area_t box = area;
+        box.y1 = area.y1 + ((area.y2 - area.y1 + 1) - lineHeight) / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, "No satellites in view", font, theme.dim, box, LV_TEXT_ALIGN_CENTER);
+        return;
+    }
+
+    const int limit = self->maxScroll();
+    if (self->scrollPx > limit) {
+        self->scrollPx = limit;
+    }
+    const int left = area.x1 + GUTTER;
+    const int origin = left - self->scrollPx;
+
+    const int markerRow = 9;
+    const int chartBottom = area.y2 - lineHeight - markerRow;
+    const int chartTop = area.y1 + lineHeight + 3;
+    const int chartHeight = chartBottom - chartTop;
+    if (chartHeight < 10) {
+        return;
+    }
+
+    // Scale lines at the colour thresholds, drawn first so the bars cover them
+    const int levels[2] = {25, 35};
+    for (int i = 0; i < 2; i++) {
+        const int y = chartBottom - levels[i] * chartHeight / MAX_SNR;
+        drawLine(layer, left, y, area.x2, y, theme.grid);
+    }
+    drawLine(layer, left, chartBottom, area.x2, chartBottom, theme.dim);
+
+    int groupStart = 0;
+    for (int i = 0; i < self->count; i++) {
+        const Satellite& sat = self->satellites[i];
+        const bool lastOfGroup = i == self->count - 1 || self->satellites[i + 1].system != sat.system;
+        const int x = origin + self->offsets[i];
+        if (x + BAR_WIDTH >= left && x <= area.x2) {
+            const int snr = sat.snr > MAX_SNR ? MAX_SNR : (sat.snr < 0 ? 0 : sat.snr);
+            const lv_color_t color = snrColor(snr, theme);
+            if (snr == 0) {
+                drawLine(layer, x, chartBottom - 1, x + BAR_WIDTH - 1, chartBottom - 1, theme.dim);
+            } else {
+                int height = snr * chartHeight / MAX_SNR;
+                if (height < 3) {
+                    height = 3;
+                }
+                lv_area_t bar;
+                bar.x1 = x;
+                bar.x2 = x + BAR_WIDTH - 1;
+                bar.y1 = chartBottom - height;
+                bar.y2 = chartBottom - 1;
+                lv_draw_rect_dsc_t rect;
+                lv_draw_rect_dsc_init(&rect);
+                rect.radius = 2;
+                if (sat.used) {
+                    rect.bg_opa = LV_OPA_COVER;
+                    rect.bg_color = color;
+                    rect.border_width = 0;
+                } else {
+                    rect.bg_opa = LV_OPA_TRANSP;
+                    rect.border_opa = LV_OPA_COVER;
+                    rect.border_color = color;
+                    rect.border_width = 1;
+                    rect.border_side = LV_BORDER_SIDE_FULL;
+                }
+                lv_draw_rect(layer, &rect, &bar);
+            }
+
+            const float centre = static_cast<float>(x) + static_cast<float>(BAR_WIDTH - 1) / 2.0f;
+            drawMarker(layer, sat.system, centre, static_cast<float>(chartBottom + markerRow / 2 + 1), 2.5f, true,
+                       systemColor(sat.system, theme));
+            lv_area_t idBox;
+            idBox.x1 = x - BAR_SPACING / 2 - 3;
+            idBox.x2 = x + BAR_WIDTH + BAR_SPACING / 2 + 2;
+            idBox.y1 = area.y2 - lineHeight + 1;
+            idBox.y2 = area.y2;
+            char id[8];
+            snprintf(id, sizeof(id), "%d", static_cast<int>(sat.id));
+            drawText(layer, id, font, theme.text, idBox, LV_TEXT_ALIGN_CENTER);
+        }
+
+        if (lastOfGroup) {
+            // Group label at the start of the group, kept in view while the group is scrolled
+            const int groupLeft = origin + self->offsets[groupStart];
+            const int groupRight = x + BAR_WIDTH;
+            const int labelWidth = 3 * lineHeight / 2 + 4;
+            int labelX = groupLeft < left ? left : groupLeft;
+            if (labelX + labelWidth > groupRight) {
+                labelX = groupRight - labelWidth;
+            }
+            if (groupRight > left && groupLeft < area.x2) {
+                lv_area_t box;
+                box.x1 = labelX;
+                box.x2 = labelX + labelWidth;
+                box.y1 = area.y1;
+                box.y2 = area.y1 + lineHeight;
+                drawText(layer, systemShortName(sat.system), font, systemColor(sat.system, theme), box,
+                         LV_TEXT_ALIGN_LEFT);
+            }
+            groupStart = i + 1;
+        }
+    }
+
+    // Scale strip on top of the scrolled content
+    drawFilledRect(layer, area.x1, area.y1, left - 3, area.y2, theme.background);
+    for (int i = 0; i < 2; i++) {
+        const int y = chartBottom - levels[i] * chartHeight / MAX_SNR;
+        lv_area_t box;
+        box.x1 = area.x1;
+        box.x2 = left - 4;
+        box.y1 = y - lineHeight / 2;
+        box.y2 = box.y1 + lineHeight;
+        char label[8];
+        snprintf(label, sizeof(label), "%d", levels[i]);
+        drawText(layer, label, font, theme.dim, box, LV_TEXT_ALIGN_LEFT);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/SkyTab.cpp b/Apps/GpsViewer/main/Source/app/SkyTab.cpp
new file mode 100644
index 0000000..489298c
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/SkyTab.cpp
@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cmath>
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr float PI_F = 3.14159265f;
+constexpr float MARKER_RADIUS = 5.0f;
+// Smallest width of the legend sidebar
+constexpr int MIN_LEGEND_WIDTH = 96;
+
+bool sameSky(const Satellite& a, const Satellite& b) {
+    return a.system == b.system && a.elevation == b.elevation && a.azimuth == b.azimuth && a.used == b.used;
+}
+
+} // namespace
+
+void SkyTab::create(lv_obj_t* parent, const Theme& themeIn) {
+    theme = &themeIn;
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_column(parent, LV_DPX(4), LV_PART_MAIN);
+
+    // The radar is as large as the height allows, but leaves room for the legend
+    int side = lv_obj_get_content_height(parent);
+    const int maxSide = lv_obj_get_content_width(parent) - LV_DPX(4) - LV_DPX(MIN_LEGEND_WIDTH);
+    if (side > maxSide) {
+        side = maxSide;
+    }
+    plot = createBox(parent);
+    lv_obj_set_size(plot, side, side);
+    lv_obj_add_event_cb(plot, onDrawRadar, LV_EVENT_DRAW_MAIN, this);
+
+    lv_obj_t* sidebar = createSection(parent);
+    setDivider(sidebar, themeIn, LV_BORDER_SIDE_LEFT);
+    lv_obj_set_height(sidebar, LV_PCT(100));
+    lv_obj_set_flex_grow(sidebar, 1);
+    lv_obj_set_style_pad_all(sidebar, LV_DPX(4), LV_PART_MAIN);
+    lv_obj_set_flex_flow(sidebar, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(sidebar, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_left(sidebar, LV_DPX(8), LV_PART_MAIN);
+    lv_obj_set_style_pad_row(sidebar, LV_DPX(4), LV_PART_MAIN);
+
+    createCaption(sidebar, themeIn, "Used / in view");
+    totalLabel = createLabel(sidebar, FONT_SIZE_LARGE, themeIn.text);
+    legend = createBox(sidebar);
+    lv_obj_set_width(legend, LV_PCT(100));
+    lv_obj_set_flex_grow(legend, 1);
+    lv_obj_add_event_cb(legend, onDrawLegend, LV_EVENT_DRAW_MAIN, this);
+    count = 0;
+    for (int i = 0; i < GNSS_SYSTEM_COUNT; i++) {
+        inView[i] = 0;
+        used[i] = 0;
+    }
+}
+
+void SkyTab::update(const TabView& view) {
+    if (plot == nullptr || legend == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+    int n = s.satelliteCount;
+    if (n > SatelliteDb::MAX_SATELLITES) {
+        n = SatelliteDb::MAX_SATELLITES;
+    }
+    if (n < 0) {
+        n = 0;
+    }
+    bool changed = n != count;
+    for (int i = 0; !changed && i < n; i++) {
+        changed = !sameSky(s.satellites[i], satellites[i]);
+    }
+    if (changed) {
+        count = n;
+        for (int i = 0; i < n; i++) {
+            satellites[i] = s.satellites[i];
+        }
+        lv_obj_invalidate(plot);
+    }
+
+    int newInView[GNSS_SYSTEM_COUNT] = {};
+    int newUsed[GNSS_SYSTEM_COUNT] = {};
+    for (int i = 0; i < n; i++) {
+        const int system = static_cast<int>(s.satellites[i].system);
+        if (system < 0 || system >= GNSS_SYSTEM_COUNT) {
+            continue;
+        }
+        newInView[system]++;
+        if (s.satellites[i].used) {
+            newUsed[system]++;
+        }
+    }
+    bool legendChanged = false;
+    for (int i = 0; i < GNSS_SYSTEM_COUNT; i++) {
+        if (newInView[i] != inView[i] || newUsed[i] != used[i]) {
+            legendChanged = true;
+            inView[i] = newInView[i];
+            used[i] = newUsed[i];
+        }
+    }
+    if (legendChanged) {
+        lv_obj_invalidate(legend);
+    }
+
+    char text[32];
+    snprintf(text, sizeof(text), "%d / %d", s.satellitesUsed, s.satellitesInView);
+    setLabelText(totalLabel, text);
+}
+
+void SkyTab::clear() {
+    plot = nullptr;
+    totalLabel = nullptr;
+    legend = nullptr;
+    theme = nullptr;
+}
+
+void SkyTab::onDrawRadar(lv_event_t* event) {
+    auto* self = static_cast<SkyTab*>(lv_event_get_user_data(event));
+    if (self->plot == nullptr || self->theme == nullptr) {
+        return;
+    }
+    const Theme& theme = *self->theme;
+    lv_layer_t* layer = lv_event_get_layer(event);
+    lv_area_t area;
+    lv_obj_get_coords(self->plot, &area);
+    const int side = area.x2 - area.x1 + 1;
+    const int cx = area.x1 + side / 2;
+    const int cy = area.y1 + side / 2;
+    const int r = side / 2 - 1;
+    if (r < 20) {
+        return;
+    }
+
+    // Rings for 0 (outer), 30 and 60 degrees elevation
+    for (int elevation = 0; elevation < 90; elevation += 30) {
+        const int rr = r * (90 - elevation) / 90;
+        drawCircle(layer, cx, cy, rr, elevation == 0 ? theme.dim : theme.grid, false, 1);
+    }
+    drawLine(layer, cx, cy - r, cx, cy + r, theme.grid);
+    drawLine(layer, cx - r, cy, cx + r, cy, theme.grid);
+
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    const int lineHeight = lv_font_get_line_height(font);
+    const int half = lineHeight / 2 + 1;
+    const struct {
+        char text[2];
+        int x;
+        int y;
+    } marks[4] = {
+        {"N", cx, cy - r + lineHeight / 2 + 2},
+        {"E", cx + r - half - 2, cy},
+        {"S", cx, cy + r - lineHeight / 2 - 2},
+        {"W", cx - r + half + 2, cy},
+    };
+    for (int i = 0; i < 4; i++) {
+        lv_area_t box;
+        box.x1 = marks[i].x - half;
+        box.x2 = marks[i].x + half;
+        box.y1 = marks[i].y - lineHeight / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, marks[i].text, font, theme.dim, box, LV_TEXT_ALIGN_CENTER);
+    }
+
+    // Unused first so the used ones end up on top
+    for (int pass = 0; pass < 2; pass++) {
+        for (int i = 0; i < self->count; i++) {
+            const Satellite& sat = self->satellites[i];
+            if (sat.elevation < 0 || sat.azimuth < 0 || sat.used != (pass == 1)) {
+                continue;
+            }
+            const float distance = static_cast<float>(r) * static_cast<float>(90 - sat.elevation) / 90.0f;
+            const float azimuth = static_cast<float>(sat.azimuth) * PI_F / 180.0f;
+            const float x = static_cast<float>(cx) + distance * std::sin(azimuth);
+            const float y = static_cast<float>(cy) - distance * std::cos(azimuth);
+            drawMarker(layer, sat.system, x, y, MARKER_RADIUS, sat.used, systemColor(sat.system, theme));
+        }
+    }
+}
+
+void SkyTab::onDrawLegend(lv_event_t* event) {
+    auto* self = static_cast<SkyTab*>(lv_event_get_user_data(event));
+    if (self->legend == nullptr || self->theme == nullptr) {
+        return;
+    }
+    const Theme& theme = *self->theme;
+    lv_layer_t* layer = lv_event_get_layer(event);
+    lv_area_t area;
+    lv_obj_get_coords(self->legend, &area);
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    const int lineHeight = lv_font_get_line_height(font);
+
+    int rows = 0;
+    for (int i = 0; i < GNSS_SYSTEM_COUNT; i++) {
+        if (self->inView[i] > 0) {
+            rows++;
+        }
+    }
+    if (rows == 0) {
+        lv_area_t box = area;
+        box.y1 = area.y1 + ((area.y2 - area.y1 + 1) - lineHeight) / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, "No satellites", font, theme.dim, box, LV_TEXT_ALIGN_CENTER);
+        return;
+    }
+    int pitch = lineHeight + 3;
+    const int available = area.y2 - area.y1 + 1;
+    if (pitch * rows > available) {
+        pitch = available / rows;
+    }
+    int y = area.y1 + (available - pitch * rows) / 2;
+    for (int k = 0; k < GNSS_SYSTEM_COUNT; k++) {
+        const int index = (k + 1) % GNSS_SYSTEM_COUNT;
+        if (self->inView[index] == 0) {
+            continue;
+        }
+        const auto system = static_cast<GnssSystem>(index);
+        const lv_color_t color = systemColor(system, theme);
+        const float markerX = static_cast<float>(area.x1) + MARKER_RADIUS + 2.0f;
+        const float markerY = static_cast<float>(y) + static_cast<float>(pitch) / 2.0f;
+        drawMarker(layer, system, markerX, markerY, MARKER_RADIUS, self->used[index] > 0, color);
+        char text[24];
+        snprintf(text, sizeof(text), "%s %d/%d", systemName(system), self->used[index], self->inView[index]);
+        lv_area_t box;
+        box.x1 = area.x1 + static_cast<int>(MARKER_RADIUS * 2.0f) + 8;
+        box.x2 = area.x2;
+        box.y1 = y + (pitch - lineHeight) / 2;
+        box.y2 = box.y1 + lineHeight;
+        drawText(layer, text, font, theme.text, box, LV_TEXT_ALIGN_LEFT);
+        y += pitch;
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Sources.cpp b/Apps/GpsViewer/main/Source/app/Sources.cpp
new file mode 100644
index 0000000..cda192f
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Sources.cpp
@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Sources.h"
+
+#include <tactility/time.h>
+
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// The location service starts the receiver when the app subscribes, so the first checks come quickly
+constexpr uint32_t CONNECT_INTERVAL_MS = 250;
+constexpr int QUEUE_LENGTH = 48;
+constexpr uint32_t READER_IDLE_MS = 100;
+constexpr uint32_t READER_STACK_SIZE = 3072;
+// Above the GPS driver's thread (THREAD_PRIORITY_HIGH, 5) so no event is overwritten before it's copied
+constexpr UBaseType_t READER_PRIORITY = 6;
+
+// Firmware headers without GpsEvent::talker select the second overload: talker unknown,
+// and satellites are then told apart by their ID ranges only
+template <typename Event>
+auto copyTalker(const Event& event, char* out, int) -> decltype(event.talker, void()) {
+    memcpy(out, event.talker, 2);
+    out[2] = '\0';
+}
+
+template <typename Event>
+void copyTalker(const Event&, char* out, long) {
+    out[0] = '\0';
+}
+
+bool toGnssEvent(const GpsEvent& in, GnssEvent& out) {
+    memset(&out, 0, sizeof(out));
+    copyTalker(in, out.talker, 0);
+    switch (in.type) {
+        case GPS_EVENT_MESSAGE_RMC:
+            out.type = GnssEventType::Rmc;
+            out.data.rmc = in.data.rmc;
+            return true;
+        case GPS_EVENT_MESSAGE_GGA:
+            out.type = GnssEventType::Gga;
+            out.data.gga = in.data.gga;
+            return true;
+        case GPS_EVENT_MESSAGE_GSV:
+            out.type = GnssEventType::Gsv;
+            out.data.gsv = in.data.gsv;
+            return true;
+        case GPS_EVENT_MESSAGE_GSA:
+            out.type = GnssEventType::Gsa;
+            out.data.gsa = in.data.gsa;
+            return true;
+        default:
+            return false;
+    }
+}
+
+// What the reader queues: the event, when it arrived and from which connection
+struct QueuedEvent {
+    GnssEvent event;
+    uint32_t atMs;
+    uint32_t session;
+};
+
+void setStatus(AppContext& context, SourceStatus status) {
+    ContextLock lock(context);
+    context.status = status;
+}
+
+} // namespace
+
+// The driver frees its state when the device stops, after it sent GPS_EVENT_UNSUBSCRIBED and
+// dropped all subscriptions. So the API is only called on a started device, and never after that event.
+void GpsSource::tryConnect(uint32_t now) {
+    if (static_cast<int32_t>(now - nextAttemptMs) < 0) {
+        return;
+    }
+    nextAttemptMs = now + CONNECT_INTERVAL_MS;
+
+    if (!location_is_enabled()) {
+        setStatus(*context, SourceStatus::LocationOff);
+        return;
+    }
+    Device* found = nullptr;
+    if (device_get_first_active_by_type(&GPS_TYPE, &found) != ERROR_NONE) {
+        Device* configured = nullptr;
+        const bool exists = device_get_first_by_type(&GPS_TYPE, &configured) == ERROR_NONE;
+        if (exists) {
+            device_put(configured);
+        }
+        setStatus(*context, lost ? SourceStatus::ReceiverLost : exists ? SourceStatus::ReceiverStarting : SourceStatus::NoReceiver);
+        return;
+    }
+    if (gps_get_state(found) != GPS_STATE_ON) {
+        device_put(found);
+        setStatus(*context, lost ? SourceStatus::ReceiverLost : SourceStatus::ReceiverStarting);
+        return;
+    }
+    subscription = {};
+    if (gps_event_subscribe(found, &subscription) != ERROR_NONE) {
+        device_put(found);
+        return;
+    }
+    device = found;
+    subscribed = true;
+    lost = false;
+
+    char name[32] = "";
+    gps_get_model_name(device, name, sizeof(name));
+    ContextLock lock(*context);
+    memcpy(context->receiverName, name, sizeof(context->receiverName));
+    context->receiverName[sizeof(context->receiverName) - 1] = '\0';
+    context->status = SourceStatus::Receiving;
+    context->model.reset(now);
+}
+
+void GpsSource::disconnect() {
+    if (subscribed) {
+        if (device_is_ready(device)) {
+            gps_event_unsubscribe(device, &subscription);
+        }
+        subscribed = false;
+        device_put(device);
+        device = nullptr;
+    }
+    lost = false;
+}
+
+void GpsSource::readerLoop() {
+    while (!stopRequested.load()) {
+        if (!subscribed) {
+            tryConnect(get_millis());
+            if (!subscribed) {
+                vTaskDelay(pdMS_TO_TICKS(READER_IDLE_MS));
+                continue;
+            }
+        }
+        if (gps_event_await(device, &subscription, pdMS_TO_TICKS(READER_IDLE_MS)) != ERROR_NONE) {
+            continue;
+        }
+        const GpsEvent event = subscription.event;
+        if (event.type == GPS_EVENT_UNSUBSCRIBED) {
+            subscribed = false;
+            lost = true;
+            device_put(device);
+            device = nullptr;
+            setStatus(*context, SourceStatus::ReceiverLost);
+            continue;
+        }
+        QueuedEvent queued;
+        if (toGnssEvent(event, queued.event)) {
+            queued.atMs = get_millis();
+            queued.session = session;
+            // A full queue drops the event, the next epoch repeats the data
+            xQueueSend(queue, &queued, 0);
+        }
+    }
+    disconnect();
+}
+
+void GpsSource::readerMain(void* argument) {
+    auto* source = static_cast<GpsSource*>(argument);
+    source->readerLoop();
+    source->readerDone.store(true);
+    vTaskDelete(nullptr);
+}
+
+// Only the location service starts GPS receivers. Its subscription also keeps the receiver running
+// while this app reads the raw sentences.
+void GpsSource::start(AppContext& appContext, TaskEventGroup* eventGroup) {
+    context = &appContext;
+    if (!locationSubscribed) {
+        location = {};
+        locationSubscribed = location_subscribe(&location, eventGroup, "GPS Viewer") == ERROR_NONE;
+    }
+    if (queue == nullptr) {
+        queue = xQueueCreate(QUEUE_LENGTH, sizeof(QueuedEvent));
+    }
+    if (queue == nullptr || !readerDone.load()) {
+        return;
+    }
+    stopRequested.store(false);
+    readerDone.store(false);
+    // The first attempt is due now. A deadline of 0 would wait for the clock to wrap after 24.9 days of uptime.
+    nextAttemptMs = get_millis();
+    if (xTaskCreatePinnedToCore(readerMain, "gpsviewer_rx", READER_STACK_SIZE, this, READER_PRIORITY, &reader, tskNO_AFFINITY) != pdPASS) {
+        readerDone.store(true);
+        reader = nullptr;
+    }
+}
+
+void GpsSource::poll(AppContext& appContext, uint32_t timeoutMs, Recorder& recorder) {
+    if (queue == nullptr) {
+        vTaskDelay(pdMS_TO_TICKS(timeoutMs));
+        return;
+    }
+    QueuedEvent queued;
+    if (xQueueReceive(queue, &queued, pdMS_TO_TICKS(timeoutMs)) != pdTRUE) {
+        return;
+    }
+    int handled = 0;
+    do {
+        bool current;
+        {
+            ContextLock lock(appContext);
+            current = queued.session == appContext.session;
+            if (current) {
+                appContext.model.onEvent(queued.event, queued.atMs);
+            }
+        }
+        if (current) {
+            recorder.write(queued.event, queued.atMs);
+        }
+        handled++;
+    } while (handled < QUEUE_LENGTH && xQueueReceive(queue, &queued, 0) == pdTRUE);
+}
+
+
+void GpsSource::stop() {
+    stopRequested.store(true);
+    // The reader wakes at least every READER_IDLE_MS
+    for (int i = 0; i < 100 && !readerDone.load(); i++) {
+        vTaskDelay(pdMS_TO_TICKS(20));
+    }
+    reader = nullptr;
+    if (locationSubscribed) {
+        location_unsubscribe(&location);
+        locationSubscribed = false;
+    }
+    if (queue != nullptr && readerDone.load()) {
+        vQueueDelete(queue);
+        queue = nullptr;
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Sources.h b/Apps/GpsViewer/main/Source/app/Sources.h
new file mode 100644
index 0000000..198f6df
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Sources.h
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "AppContext.h"
+#include "Recorder.h"
+
+#include <gps/gps.h>
+#include <location/location.h>
+#include <tactility/device.h>
+
+#include <freertos/queue.h>
+#include <freertos/task.h>
+
+#include <atomic>
+
+namespace gpsviewer {
+
+// Live data from the first started GPS_TYPE device.
+// A reader task waits for the GPS events and copies them into a queue, which the app task drains.
+class GpsSource {
+public:
+    // Subscribes to the location service, which starts the receiver and shows the location icon,
+    // and starts the reader task. App task only.
+    void start(AppContext& context, TaskEventGroup* eventGroup);
+    // Feeds queued events into the model and the recorder, waiting at most timeoutMs for the first. App task only.
+    void poll(AppContext& context, uint32_t timeoutMs, Recorder& recorder);
+    // Stops the reader task, which drops the GPS subscription, then the location subscription. App task only.
+    void stop();
+
+private:
+    static void readerMain(void* argument);
+    void readerLoop();
+    // Reader task only
+    void tryConnect(uint32_t now);
+    void disconnect();
+
+    AppContext* context = nullptr;
+    QueueHandle_t queue = nullptr;
+    TaskHandle_t reader = nullptr;
+    std::atomic<bool> stopRequested {false};
+    std::atomic<bool> readerDone {true};
+    LocationSubscription location {};
+    bool locationSubscribed = false;
+
+
+    // Reader task only
+    Device* device = nullptr;
+    GpsSubscription subscription {};
+    bool subscribed = false;
+    uint32_t session = 0;
+    uint32_t nextAttemptMs = 0;
+    bool lost = false;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/StatusTab.cpp b/Apps/GpsViewer/main/Source/app/StatusTab.cpp
new file mode 100644
index 0000000..2555d62
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/StatusTab.cpp
@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <cmath>
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr int DOT_SIZE = 14;
+
+const char* dopQualityWord(float value) {
+    if (std::isnan(value)) {
+        return "";
+    }
+    if (value < 1.0f) {
+        return "Ideal";
+    }
+    if (value < 2.0f) {
+        return "Excellent";
+    }
+    if (value < 5.0f) {
+        return "Good";
+    }
+    if (value < 10.0f) {
+        return "Moderate";
+    }
+    if (value < 20.0f) {
+        return "Fair";
+    }
+    return "Poor";
+}
+
+lv_obj_t* createRow(lv_obj_t* parent) {
+    lv_obj_t* row = createBox(parent);
+    lv_obj_set_size(row, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_flex_flow(row, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_column(row, LV_DPX(4), LV_PART_MAIN);
+    return row;
+}
+
+lv_obj_t* createSpacer(lv_obj_t* parent) {
+    lv_obj_t* spacer = createBox(parent);
+    lv_obj_set_size(spacer, 1, 1);
+    lv_obj_set_flex_grow(spacer, 1);
+    return spacer;
+}
+
+// Full-width block, with a divider below unless it is the last one
+lv_obj_t* createBlock(lv_obj_t* parent, const Theme& theme, bool divider) {
+    lv_obj_t* block = createSection(parent);
+    lv_obj_set_size(block, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_ver(block, LV_DPX(5), LV_PART_MAIN);
+    if (divider) {
+        setDivider(block, theme, LV_BORDER_SIDE_BOTTOM);
+    }
+    return block;
+}
+
+} // namespace
+
+void StatusTab::create(lv_obj_t* parent, const Theme& theme) {
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(parent, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    lv_obj_set_style_pad_row(parent, 0, LV_PART_MAIN);
+
+    // Fix card: status indicator on the left, accuracy on the right
+    lv_obj_t* fixCard = createBlock(parent, theme, true);
+    lv_obj_set_flex_flow(fixCard, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(fixCard, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_column(fixCard, LV_DPX(6), LV_PART_MAIN);
+    fixDot = createBox(fixCard);
+    lv_obj_set_size(fixDot, DOT_SIZE, DOT_SIZE);
+    lv_obj_set_style_radius(fixDot, LV_RADIUS_CIRCLE, LV_PART_MAIN);
+    lv_obj_set_style_border_color(fixDot, theme.dim, LV_PART_MAIN);
+    lv_obj_set_style_border_width(fixDot, 2, LV_PART_MAIN);
+    fixLabel = createLabel(fixCard, FONT_SIZE_LARGE, theme.dim);
+    createSpacer(fixCard);
+    lv_obj_t* accuracy = createBox(fixCard);
+    lv_obj_set_size(accuracy, LV_SIZE_CONTENT, LV_SIZE_CONTENT);
+    // One line: "est." next to the value, so the tab fits the T-Deck's content height
+    lv_obj_set_flex_flow(accuracy, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(accuracy, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END);
+    lv_obj_set_style_pad_column(accuracy, LV_DPX(3), LV_PART_MAIN);
+    lv_obj_t* estimate = createLabel(accuracy, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(estimate, "est.");
+    accuracyLabel = createLabel(accuracy, FONT_SIZE_LARGE, theme.accent);
+
+    // DOP card: three columns
+    lv_obj_t* dopCard = createBlock(parent, theme, true);
+    lv_obj_set_flex_flow(dopCard, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(dopCard, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
+    const char captions[3][5] = {"HDOP", "VDOP", "PDOP"};
+    for (int i = 0; i < 3; i++) {
+        lv_obj_t* column = createBox(dopCard);
+        lv_obj_set_size(column, LV_PCT(32), LV_SIZE_CONTENT);
+        lv_obj_set_flex_flow(column, LV_FLEX_FLOW_COLUMN);
+        createCaption(column, theme, captions[i]);
+        lv_obj_t* row = createRow(column);
+        lv_obj_set_flex_align(row, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_END, LV_FLEX_ALIGN_END);
+        dopValue[i] = createLabel(row, FONT_SIZE_DEFAULT, theme.text);
+        dopQuality[i] = createLabel(row, FONT_SIZE_SMALL, theme.dim);
+    }
+
+    // Satellites, time to first fix, receiver
+    lv_obj_t* infoCard = createBlock(parent, theme, false);
+    lv_obj_set_flex_flow(infoCard, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(infoCard, LV_DPX(2), LV_PART_MAIN);
+    lv_obj_t* satellitesRow = createRow(infoCard);
+    lv_obj_t* satellitesCaption = createLabel(satellitesRow, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(satellitesCaption, "Satellites used / in view");
+    createSpacer(satellitesRow);
+    satellitesLabel = createLabel(satellitesRow, FONT_SIZE_DEFAULT, theme.text);
+    lv_obj_t* ttffRow = createRow(infoCard);
+    lv_obj_t* ttffCaption = createLabel(ttffRow, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(ttffCaption, "Time to first fix");
+    createSpacer(ttffRow);
+    ttffLabel = createLabel(ttffRow, FONT_SIZE_DEFAULT, theme.text);
+    ttffNote = createLabel(ttffRow, FONT_SIZE_SMALL, theme.dim);
+    receiverLabel = createLabel(infoCard, FONT_SIZE_SMALL, theme.dim);
+    lv_obj_set_width(receiverLabel, LV_PCT(100));
+    lastFix = -1;
+}
+
+void StatusTab::update(const TabView& view) {
+    if (fixDot == nullptr || fixLabel == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = view.snapshot;
+    const Theme& theme = view.theme;
+    const int fix = static_cast<int>(s.fix);
+    if (fix != lastFix) {
+        lastFix = fix;
+        const lv_color_t color = fixColor(s.fix, theme);
+        // Filled dot with a fix, hollow ring without
+        lv_obj_set_style_bg_color(fixDot, color, LV_PART_MAIN);
+        lv_obj_set_style_bg_opa(fixDot, s.fix == FixType::None ? LV_OPA_TRANSP : LV_OPA_COVER, LV_PART_MAIN);
+        lv_obj_set_style_border_color(fixDot, color, LV_PART_MAIN);
+        lv_obj_set_style_text_color(fixLabel, color, LV_PART_MAIN);
+    }
+    setLabelText(fixLabel, fixText(s.fix));
+
+    char text[96];
+    if (std::isnan(s.hdop)) {
+        setLabelText(accuracyLabel, "--");
+    } else {
+        char accuracy[24];
+        formatAccuracy(estimatedAccuracyMeters(s.hdop), view.settings.units, accuracy, sizeof(accuracy));
+        snprintf(text, sizeof(text), "\xC2\xB1%s", accuracy);
+        setLabelText(accuracyLabel, text);
+    }
+
+    const float dops[3] = {s.hdop, s.vdop, s.pdop};
+    for (int i = 0; i < 3; i++) {
+        if (std::isnan(dops[i])) {
+            setLabelText(dopValue[i], "--");
+        } else {
+            snprintf(text, sizeof(text), "%.1f", static_cast<double>(dops[i]));
+            setLabelText(dopValue[i], text);
+        }
+        setLabelText(dopQuality[i], dopQualityWord(dops[i]));
+    }
+
+    snprintf(text, sizeof(text), "%d / %d", s.satellitesUsed, s.satellitesInView);
+    setLabelText(satellitesLabel, text);
+
+    char duration[24];
+    if (s.hasTtff) {
+        formatDuration(s.ttffMs / 1000, duration, sizeof(duration));
+        setLabelText(ttffLabel, duration);
+        setLabelText(ttffNote, "since app start");
+    } else {
+        formatDuration(s.listeningMs / 1000, duration, sizeof(duration));
+        snprintf(text, sizeof(text), "searching %s", duration);
+        setLabelText(ttffLabel, text);
+        setLabelText(ttffNote, "since app start");
+    }
+
+    if (view.receiverName[0] == '\0') {
+        snprintf(text, sizeof(text), "Receiver: unknown");
+    } else {
+        snprintf(text, sizeof(text), "Receiver: %s", view.receiverName);
+    }
+    setLabelText(receiverLabel, text);
+}
+
+void StatusTab::clear() {
+    fixDot = nullptr;
+    fixLabel = nullptr;
+    accuracyLabel = nullptr;
+    for (int i = 0; i < 3; i++) {
+        dopValue[i] = nullptr;
+        dopQuality[i] = nullptr;
+    }
+    satellitesLabel = nullptr;
+    ttffLabel = nullptr;
+    ttffNote = nullptr;
+    receiverLabel = nullptr;
+    lastFix = -1;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Tabs.h b/Apps/GpsViewer/main/Source/app/Tabs.h
new file mode 100644
index 0000000..edbd384
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Tabs.h
@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "AppContext.h"
+
+#include <lvgl.h>
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+struct Theme {
+    bool night;
+    // Monochrome theme: no colours, shapes and fills only
+    bool mono;
+    // Screen background behind the app. Only painted in night mode, otherwise the window's own.
+    lv_color_t background;
+    bool paintBackground;
+    // Divider lines
+    lv_color_t border;
+    lv_color_t accent;
+    lv_color_t success;
+    lv_color_t warning;
+    lv_color_t text;
+    // Secondary labels and units
+    lv_color_t dim;
+    // Radar rings, chart lines
+    lv_color_t grid;
+};
+
+Theme makeTheme(bool night);
+// Day: >= 35 dB-Hz success, 25..34 warning, below that the dim colour. Night: three reds.
+lv_color_t snrColor(int snr, const Theme& theme);
+lv_color_t systemColor(GnssSystem system, const Theme& theme);
+// Sets the label text only when it differs, so unchanged labels cause no redraw
+void setLabelText(lv_obj_t* label, const char* text);
+
+// What every tab gets on each refresh. LVGL thread only.
+struct TabView {
+    const GnssSnapshot& snapshot;
+    const Settings& settings;
+    SourceStatus status;
+    bool recording;
+    const char* receiverName;
+    const Theme& theme;
+};
+
+// Each tab builds its widgets in create() inside `parent` (the content area, about 312x150 on a
+// T-Deck, sizes from lv_obj_get_content_width/height), and update() only changes what differs.
+// clear() forgets the widget pointers after LVGL deleted them.
+
+class StatusTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+
+private:
+    lv_obj_t* fixDot = nullptr;
+    lv_obj_t* fixLabel = nullptr;
+    lv_obj_t* accuracyLabel = nullptr;
+    lv_obj_t* dopValue[3] {};
+    lv_obj_t* dopQuality[3] {};
+    lv_obj_t* satellitesLabel = nullptr;
+    lv_obj_t* ttffLabel = nullptr;
+    lv_obj_t* ttffNote = nullptr;
+    lv_obj_t* receiverLabel = nullptr;
+    int lastFix = -1;
+};
+
+class SignalTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+    // Scrolls the bars by a few satellites. Returns false when already at that end.
+    bool scroll(int direction);
+
+private:
+    static void onDraw(lv_event_t* event);
+    static void onPress(lv_event_t* event);
+    int contentWidth() const;
+    int maxScroll() const;
+
+    lv_obj_t* summaryLabel = nullptr;
+    lv_obj_t* bars = nullptr;
+    const Theme* theme = nullptr;
+    int count = 0;
+    Satellite satellites[SatelliteDb::MAX_SATELLITES] {};
+    // X of each bar relative to the first one, group gaps included
+    int16_t offsets[SatelliteDb::MAX_SATELLITES] {};
+    int totalWidth = 0;
+    int scrollPx = 0;
+    int dragStartX = 0;
+    int dragStartScroll = 0;
+    bool dragging = false;
+};
+
+class SkyTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+
+private:
+    static void onDrawRadar(lv_event_t* event);
+    static void onDrawLegend(lv_event_t* event);
+
+    lv_obj_t* plot = nullptr;
+    lv_obj_t* totalLabel = nullptr;
+    lv_obj_t* legend = nullptr;
+    const Theme* theme = nullptr;
+    int count = 0;
+    Satellite satellites[SatelliteDb::MAX_SATELLITES] {};
+    int inView[GNSS_SYSTEM_COUNT] {};
+    int used[GNSS_SYSTEM_COUNT] {};
+};
+
+class PositionTab {
+public:
+    void create(lv_obj_t* parent, const Theme& theme);
+    void update(const TabView& view);
+    void clear();
+
+private:
+    lv_obj_t* latitudeLabel = nullptr;
+    lv_obj_t* longitudeLabel = nullptr;
+    lv_obj_t* altitudeLabel = nullptr;
+    lv_obj_t* courseLabel = nullptr;
+    lv_obj_t* speedLabel = nullptr;
+    lv_obj_t* speedUnitLabel = nullptr;
+    lv_obj_t* speedStatsLabel = nullptr;
+    lv_obj_t* riseLabel = nullptr;
+    lv_obj_t* setRow = nullptr;
+    lv_obj_t* setLabel = nullptr;
+    lv_obj_t* timeLabel = nullptr;
+    lv_obj_t* recPill = nullptr;
+    // Column width the coordinate fonts were picked for
+    int fitWidth = -1;
+    int sunYear = 0;
+    int sunMonth = 0;
+    int sunDay = 0;
+    double sunLatitude = 1000;
+    double sunLongitude = 1000;
+    char riseText[24] = "";
+    char setText[24] = "";
+};
+
+// Centred card for the states without data: alert icon, title, help line and an optional
+// OPEN SETTINGS button. It lives in the content area next to the tab panels.
+class MessageCard {
+public:
+    // onSettings is called on click, onKey gets the keys of the focused button
+    void create(lv_obj_t* parent, const Theme& theme, lv_event_cb_t onSettings, lv_event_cb_t onKey, void* userData);
+    void clear();
+    // Shows the card for a status without data and returns true, or hides it and returns false
+    bool update(SourceStatus status, const char* dataDirectory);
+    lv_obj_t* focusTarget() const { return button; }
+    bool shown() const { return visible; }
+
+private:
+    lv_obj_t* card = nullptr;
+    lv_obj_t* titleLabel = nullptr;
+    lv_obj_t* helpLabel = nullptr;
+    lv_obj_t* button = nullptr;
+    bool visible = false;
+    bool buttonInGroup = false;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Theme.cpp b/Apps/GpsViewer/main/Source/app/Theme.cpp
new file mode 100644
index 0000000..2353c6d
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Theme.cpp
@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Tabs.h"
+
+#include <lvgl/theme.h>
+
+#include <cstring>
+
+namespace gpsviewer {
+
+Theme makeTheme(bool night) {
+    Theme theme {};
+    theme.night = night;
+    const bool mono = lvgl_theme_is_mono();
+    if (night && mono) {
+        // A 1-bit display has no dark reds: white on black, shapes carry the hierarchy
+        theme.background = lv_color_black();
+        theme.paintBackground = true;
+        theme.border = lv_color_white();
+        theme.accent = lv_color_white();
+        theme.success = lv_color_white();
+        theme.warning = lv_color_white();
+        theme.text = lv_color_white();
+        theme.dim = lv_color_white();
+        theme.grid = lv_color_white();
+        theme.mono = true;
+        return theme;
+    }
+    if (night) {
+        // Tactical red: one hue only, brightness carries the hierarchy
+        theme.background = lv_color_hex(0x000000);
+        theme.paintBackground = true;
+        theme.border = lv_color_hex(0x380C0C);
+        theme.accent = lv_color_hex(0xFF2A2A);
+        theme.success = lv_color_hex(0xFF2A2A);
+        theme.warning = lv_color_hex(0xB81F1F);
+        theme.text = lv_color_hex(0xFF2A2A);
+        theme.dim = lv_color_hex(0x7A1E1E);
+        theme.grid = lv_color_hex(0x4A1212);
+        return theme;
+    }
+    // The theme's own tones (Material 3 neutrals of the Tactility theme), for what the app draws itself
+    LvglThemeSettings settings;
+    lvgl_theme_get_settings(&settings);
+    const bool dark = settings.is_dark;
+    theme.background = dark ? lv_color_hex(0x21222B) : lv_color_hex(0xF3F3F3);
+    if (settings.surface_override) {
+        theme.background = settings.color_surface;
+    }
+    theme.paintBackground = false;
+    theme.text = dark ? lv_color_hex(0xE2E2E2) : lv_color_hex(0x1C1C1C);
+    theme.dim = dark ? lv_color_hex(0x919191) : lv_color_hex(0x5E5E5E);
+    theme.border = dark ? lv_color_hex(0x3A3B44) : lv_color_hex(0xD6D6D6);
+    theme.grid = dark ? lv_color_hex(0x4A4B55) : lv_color_hex(0xC6C6C6);
+    theme.accent = mono ? theme.text : settings.color_primary;
+    theme.success = mono ? theme.text : lv_palette_main(LV_PALETTE_GREEN);
+    theme.warning = mono ? theme.dim : lv_palette_main(LV_PALETTE_AMBER);
+    theme.mono = mono;
+    return theme;
+}
+
+lv_color_t snrColor(int snr, const Theme& theme) {
+    if (snr >= 35) {
+        return theme.success;
+    }
+    if (snr >= 25) {
+        return theme.warning;
+    }
+    return theme.dim;
+}
+
+lv_color_t systemColor(GnssSystem system, const Theme& theme) {
+    if (theme.mono) {
+        return theme.text;
+    }
+    if (theme.night) {
+        switch (system) {
+            case GnssSystem::Gps:
+            case GnssSystem::Glonass:
+            case GnssSystem::Galileo:
+            case GnssSystem::Beidou:
+            case GnssSystem::Qzss:
+                return theme.text;
+            default:
+                return theme.warning;
+        }
+    }
+    switch (system) {
+        case GnssSystem::Gps: return lv_color_hex(0x3B82F6);
+        case GnssSystem::Glonass: return lv_color_hex(0xF59E0B);
+        case GnssSystem::Galileo: return lv_color_hex(0x06B6D4);
+        case GnssSystem::Beidou: return lv_color_hex(0xA855F7);
+        case GnssSystem::Qzss: return lv_color_hex(0xEC4899);
+        case GnssSystem::Sbas: return lv_color_hex(0xA3E635);
+        case GnssSystem::Navic: return lv_color_hex(0xFB7185);
+        default: return lv_color_hex(0x8E9BAE);
+    }
+}
+
+void setLabelText(lv_obj_t* label, const char* text) {
+    if (label == nullptr) {
+        return;
+    }
+    if (strcmp(lv_label_get_text(label), text) != 0) {
+        lv_label_set_text(label, text);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Ui.cpp b/Apps/GpsViewer/main/Source/app/Ui.cpp
new file mode 100644
index 0000000..10a6b79
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Ui.cpp
@@ -0,0 +1,869 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Ui.h"
+#include "Tabs.h"
+#include "Widgets.h"
+
+#include <app/event.h>
+#include <lvgl/fonts.h>
+#include <lvgl/devices/keyboard.h>
+#include <lvgl/grid_navigation.h>
+#include <lvgl/icons/shared.h>
+#include <lvgl/widgets/toolbar.h>
+#include <tactility/Memory.hpp>
+#include <tactility/time.h>
+
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// lv_color_to_u32() is not exported to apps
+uint32_t colorKey(lv_color_t color) {
+    return (static_cast<uint32_t>(color.red) << 16) | (static_cast<uint32_t>(color.green) << 8) | color.blue;
+}
+
+constexpr int TAB_COUNT = 4;
+constexpr uint32_t REFRESH_MS = 333;
+constexpr lv_state_t NIGHT_STATE = LV_STATE_USER_4;
+constexpr lv_style_selector_t NIGHT_SELECTOR = static_cast<lv_style_selector_t>(LV_PART_MAIN) | static_cast<lv_style_selector_t>(NIGHT_STATE);
+
+// Tab order. The indices are also the keys 1 to 4.
+enum TabIndex : int {
+    TAB_POSITION = 0,
+    TAB_SKY = 1,
+    TAB_SIGNAL = 2,
+    TAB_STATUS = 3,
+};
+
+// Character arrays, not string pointers: the app loader leaves pointers in data tables unrelocated
+constexpr char TAB_NAMES[TAB_COUNT][9] = {"Position", "Sky", "Signal", "Status"};
+
+enum class Overlay : uint8_t {
+    None,
+    Menu,
+    Settings,
+};
+
+enum class MenuItem : uint8_t {
+    ResetSpeed,
+    Recording,
+    NightMode,
+    OpenSettings,
+    Exit,
+    Back,
+};
+
+enum class SettingItem : uint8_t {
+    Units,
+    Coordinates,
+    Night,
+    Back,
+};
+
+} // namespace
+
+struct UiState {
+    AppContext* context = nullptr;
+    Theme theme {};
+    lv_obj_t* root = nullptr;
+    lv_obj_t* header = nullptr;
+    lv_obj_t* headerBadge = nullptr;
+    uint32_t badgeColor = 0;
+    lv_obj_t* tabButtons[TAB_COUNT] {};
+    lv_obj_t* tabIndicators[TAB_COUNT] {};
+    lv_obj_t* content = nullptr;
+    lv_obj_t* panels[TAB_COUNT] {};
+    MessageCard messageCard;
+    lv_obj_t* overlay = nullptr;
+    // The keys go to this group while an overlay is open, so the focus can't leave it
+    lv_group_t* overlayGroup = nullptr;
+    lv_timer_t* timer = nullptr;
+    Overlay overlayType = Overlay::None;
+    int activeTab = 0;
+    // Left and Right scroll the Signal bars instead of switching tabs
+    bool signalScrolling = false;
+    bool rebuildPending = false;
+    SourceStatus status = SourceStatus::NoReceiver;
+    char receiverName[32] = "";
+    bool recording = false;
+    uint32_t recordedLines = 0;
+    Settings settings {};
+    StatusTab statusTab;
+    SignalTab signalTab;
+    SkyTab skyTab;
+    PositionTab positionTab;
+    GnssSnapshot snapshot {};
+};
+
+namespace {
+
+void build(UiState& ui);
+void refresh(UiState& ui);
+void setNightMode(UiState& ui, bool enable);
+
+// Fix state in the toolbar: "3D FIX  3.5m", prefixed with REC
+void updateHeader(UiState& ui) {
+    if (ui.headerBadge == nullptr) {
+        return;
+    }
+    const GnssSnapshot& s = ui.snapshot;
+    const bool receiving = ui.status == SourceStatus::Receiving;
+    const FixType fix = receiving ? s.fix : FixType::None;
+    char text[40];
+    size_t length = 0;
+    text[0] = '\0';
+    if (ui.recording) {
+        length = static_cast<size_t>(snprintf(text, sizeof(text), "REC  "));
+    }
+    length += static_cast<size_t>(snprintf(text + length, sizeof(text) - length, "%s", fixText(fix)));
+    if (fix != FixType::None && !std::isnan(s.hdop) && length < sizeof(text)) {
+        char accuracy[24];
+        formatAccuracy(estimatedAccuracyMeters(s.hdop), ui.settings.units, accuracy, sizeof(accuracy));
+        // "3.5 m" -> "3.5m"
+        size_t out = 0;
+        for (size_t i = 0; accuracy[i] != '\0'; i++) {
+            if (accuracy[i] != ' ') {
+                accuracy[out++] = accuracy[i];
+            }
+        }
+        accuracy[out] = '\0';
+        snprintf(text + length, sizeof(text) - length, "  %s", accuracy);
+    }
+    lv_color_t color = fixColor(fix, ui.theme);
+    if (ui.recording) {
+        color = ui.theme.warning;
+    }
+    setLabelText(ui.headerBadge, text);
+    const uint32_t colorValue = colorKey(color);
+    if (colorValue != ui.badgeColor) {
+        ui.badgeColor = colorValue;
+        lv_obj_set_style_text_color(ui.headerBadge, color, LV_PART_MAIN);
+    }
+}
+
+void styleTabButtons(UiState& ui) {
+    for (int i = 0; i < TAB_COUNT; i++) {
+        lv_obj_t* button = ui.tabButtons[i];
+        if (button == nullptr) {
+            continue;
+        }
+        const bool active = i == ui.activeTab;
+        setHidden(ui.tabIndicators[i], !active);
+        lv_obj_t* label = lv_obj_get_child(button, 0);
+        lv_obj_set_style_text_color(label, active ? ui.theme.accent : ui.theme.dim, LV_PART_MAIN);
+    }
+}
+
+// The content area gets an outline while the keys scroll the Signal bars
+void setSignalScrolling(UiState& ui, bool scrolling) {
+    ui.signalScrolling = scrolling;
+    if (ui.content == nullptr) {
+        return;
+    }
+    const int32_t width = scrolling ? 2 : 0;
+    for (const lv_style_selector_t state : { LV_STATE_DEFAULT, LV_STATE_FOCUSED, LV_STATE_FOCUS_KEY }) {
+        lv_obj_set_style_outline_color(ui.content, ui.theme.accent, state);
+        lv_obj_set_style_outline_width(ui.content, width, state);
+        lv_obj_set_style_outline_pad(ui.content, -2, state);
+    }
+}
+
+void setTab(UiState& ui, int tab) {
+    ui.activeTab = (tab + TAB_COUNT) % TAB_COUNT;
+    if (ui.activeTab != TAB_SIGNAL && ui.signalScrolling) {
+        setSignalScrolling(ui, false);
+    }
+    styleTabButtons(ui);
+    refresh(ui);
+}
+
+void requestBits(UiState& ui, uint32_t bits) {
+    ui.context->requests.fetch_or(bits);
+}
+
+void toggleRecording(UiState& ui) {
+    ui.context->recordingToggles.fetch_add(1);
+}
+
+void applySettings(UiState& ui, const Settings& settings) {
+    {
+        ContextLock lock(*ui.context);
+        ui.context->settings = settings;
+    }
+    ui.settings = settings;
+    requestBits(ui, REQUEST_SAVE_SETTINGS);
+}
+
+// Stores the palette choice. The widget tree is rebuilt with the other palette on the next timer
+// tick (or when the overlay is closed), as there are no shared styles to restyle in place.
+void setNightMode(UiState& ui, bool enable) {
+    Settings settings = ui.settings;
+    if (settings.nightMode == enable) {
+        return;
+    }
+    settings.nightMode = enable;
+    applySettings(ui, settings);
+    ui.rebuildPending = true;
+}
+
+void toggleNight(UiState& ui) {
+    setNightMode(ui, !ui.settings.nightMode);
+}
+
+// Keys go to the content area, or to OPEN SETTINGS while a message card with that button is shown
+void focusMain(UiState& ui) {
+    lv_group_t* group = lv_group_get_default();
+    if (group == nullptr) {
+        return;
+    }
+    lv_obj_t* target = ui.content;
+    if (ui.messageCard.shown() && ui.messageCard.focusTarget() != nullptr &&
+        !lv_obj_has_flag(ui.messageCard.focusTarget(), LV_OBJ_FLAG_HIDDEN)) {
+        target = ui.messageCard.focusTarget();
+    }
+    if (target != nullptr) {
+        lv_group_focus_obj(target);
+    }
+}
+
+// Hands the keys back to the app's group and drops the overlay's
+void releaseOverlayGroup(UiState& ui) {
+    if (ui.overlayGroup != nullptr) {
+        lvgl_keyboard_set_active_group(nullptr);
+        lv_group_delete(ui.overlayGroup);
+        ui.overlayGroup = nullptr;
+    }
+}
+
+void closeOverlay(UiState& ui) {
+    releaseOverlayGroup(ui);
+    if (ui.overlay != nullptr) {
+        lv_obj_delete_async(ui.overlay);
+        ui.overlay = nullptr;
+    }
+    ui.overlayType = Overlay::None;
+    focusMain(ui);
+}
+
+// The next button in the list from index, wrapping around, past the title
+lv_obj_t* nextOverlayButton(lv_obj_t* list, int index, int step) {
+    const int count = static_cast<int>(lv_obj_get_child_count(list));
+    for (int i = 1; i < count; i++) {
+        lv_obj_t* child = lv_obj_get_child(list, ((index + step * i) % count + count) % count);
+        // The buttons are clickable, the title is not
+        if (lv_obj_has_flag(child, LV_OBJ_FLAG_CLICKABLE)) {
+            return child;
+        }
+    }
+    return nullptr;
+}
+
+// Overlay lists get Left/Up and Right/Down as focus moves, and Esc/Backspace to close
+void onOverlayItemKey(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_obj_t* item = lv_event_get_current_target_obj(event);
+    const uint32_t key = lv_event_get_key(event);
+    lv_obj_t* list = lv_obj_get_parent(item);
+    const int index = static_cast<int>(lv_obj_get_index(item));
+    if (key == LV_KEY_LEFT || key == LV_KEY_UP || key == LV_KEY_RIGHT || key == LV_KEY_DOWN) {
+        const int step = (key == LV_KEY_LEFT || key == LV_KEY_UP) ? -1 : 1;
+        lv_obj_t* next = nextOverlayButton(list, index, step);
+        if (next != nullptr) {
+            lv_group_focus_obj(next);
+        }
+    } else if (key == LV_KEY_ESC || key == LV_KEY_BACKSPACE) {
+        closeOverlay(*ui);
+    }
+}
+
+void onOverlayBackdrop(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    if (lv_event_get_target_obj(event) == ui->overlay) {
+        closeOverlay(*ui);
+    }
+}
+
+lv_obj_t* createOverlay(UiState& ui, Overlay type, const char* title) {
+    closeOverlay(ui);
+    ui.overlayType = type;
+    ui.overlay = lv_obj_create(ui.root);
+    lv_obj_add_flag(ui.overlay, LV_OBJ_FLAG_FLOATING);
+    lv_obj_set_size(ui.overlay, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_style_bg_color(ui.overlay, lv_color_black(), LV_PART_MAIN);
+    lv_obj_set_style_bg_opa(ui.overlay, LV_OPA_60, LV_PART_MAIN);
+    lv_obj_set_style_border_width(ui.overlay, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(ui.overlay, 0, LV_PART_MAIN);
+    lv_obj_add_event_cb(ui.overlay, onOverlayBackdrop, LV_EVENT_CLICKED, &ui);
+
+    ui.overlayGroup = lv_group_create();
+    if (ui.overlayGroup != nullptr) {
+        lvgl_keyboard_set_active_group(ui.overlayGroup);
+    }
+
+    lv_obj_t* list = lv_list_create(ui.overlay);
+    lv_obj_set_size(list, LV_PCT(80), LV_PCT(95));
+    lv_obj_center(list);
+    lv_obj_t* titleLabel = lv_list_add_text(list, title);
+    if (ui.theme.night) {
+        const Theme& theme = ui.theme;
+        lv_obj_set_style_bg_color(list, theme.background, LV_PART_MAIN);
+        lv_obj_set_style_border_color(list, theme.border, LV_PART_MAIN);
+        lv_obj_set_style_bg_color(titleLabel, theme.background, LV_PART_MAIN);
+        lv_obj_set_style_text_color(titleLabel, theme.dim, LV_PART_MAIN);
+    }
+    return list;
+}
+
+// Night mode: dark buttons with red text, and a dark red fill on the focused one
+void paintOverlayButton(lv_obj_t* button, const Theme& theme) {
+    lv_obj_set_style_bg_color(button, theme.background, LV_PART_MAIN);
+    lv_obj_set_style_text_color(button, theme.text, LV_PART_MAIN);
+    lv_obj_set_style_border_color(button, theme.border, LV_PART_MAIN);
+    for (const lv_style_selector_t state : { LV_STATE_FOCUSED, LV_STATE_FOCUS_KEY, LV_STATE_PRESSED }) {
+        lv_obj_set_style_bg_color(button, theme.mono ? theme.text : theme.border, state);
+        lv_obj_set_style_bg_opa(button, LV_OPA_COVER, state);
+        lv_obj_set_style_text_color(button, theme.mono ? theme.background : theme.accent, state);
+    }
+}
+
+lv_obj_t* addOverlayItem(UiState& ui, lv_obj_t* list, const char* text, lv_event_cb_t onClick, uint32_t id) {
+    lv_obj_t* button = lv_list_add_button(list, nullptr, text);
+    lv_obj_set_user_data(button, reinterpret_cast<void*>(static_cast<uintptr_t>(id)));
+    lv_obj_add_event_cb(button, onClick, LV_EVENT_CLICKED, &ui);
+    lv_obj_add_event_cb(button, onOverlayItemKey, LV_EVENT_KEY, &ui);
+    if (ui.theme.night) {
+        paintOverlayButton(button, ui.theme);
+    }
+    if (ui.overlayGroup != nullptr) {
+        lv_group_add_obj(ui.overlayGroup, button);
+    }
+    return button;
+}
+
+uint32_t itemId(lv_event_t* event) {
+    return static_cast<uint32_t>(reinterpret_cast<uintptr_t>(lv_obj_get_user_data(lv_event_get_current_target_obj(event))));
+}
+
+void openSettings(UiState& ui);
+
+void onMenuItem(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    const auto item = static_cast<MenuItem>(itemId(event));
+    switch (item) {
+        case MenuItem::ResetSpeed:
+            requestBits(*ui, REQUEST_RESET_SPEED);
+            closeOverlay(*ui);
+            break;
+        case MenuItem::Recording:
+            toggleRecording(*ui);
+            closeOverlay(*ui);
+            break;
+        case MenuItem::NightMode:
+            closeOverlay(*ui);
+            toggleNight(*ui);
+            break;
+        case MenuItem::OpenSettings:
+            openSettings(*ui);
+            break;
+        case MenuItem::Exit:
+            closeOverlay(*ui);
+            app_event_emit_close(ui->context->appInstanceId);
+            break;
+        case MenuItem::Back:
+            closeOverlay(*ui);
+            break;
+    }
+}
+
+void openMenu(UiState& ui) {
+    lv_obj_t* list = createOverlay(ui, Overlay::Menu, "GPS Viewer");
+    lv_obj_t* first = addOverlayItem(ui, list, "Reset max/average speed", onMenuItem, static_cast<uint32_t>(MenuItem::ResetSpeed));
+    char recordText[48];
+    const bool canRecord = ui.context->dataDirectory[0] != '\0';
+    if (ui.recording) {
+        snprintf(recordText, sizeof(recordText), "Stop recording (%lu lines)", static_cast<unsigned long>(ui.recordedLines));
+    } else if (canRecord) {
+        snprintf(recordText, sizeof(recordText), "Start recording");
+    } else {
+        snprintf(recordText, sizeof(recordText), "No storage: can't record or save settings");
+    }
+    lv_obj_t* recordItem = addOverlayItem(ui, list, recordText, onMenuItem, static_cast<uint32_t>(MenuItem::Recording));
+    if (!ui.recording && !canRecord) {
+        lv_obj_add_state(recordItem, LV_STATE_DISABLED);
+    }
+    addOverlayItem(ui, list, ui.settings.nightMode ? "Night mode: off" : "Night mode: on", onMenuItem, static_cast<uint32_t>(MenuItem::NightMode));
+    addOverlayItem(ui, list, "Settings", onMenuItem, static_cast<uint32_t>(MenuItem::OpenSettings));
+    addOverlayItem(ui, list, "Exit", onMenuItem, static_cast<uint32_t>(MenuItem::Exit));
+    addOverlayItem(ui, list, "< Back", onMenuItem, static_cast<uint32_t>(MenuItem::Back));
+    if (first != nullptr) {
+        lv_group_focus_obj(first);
+    }
+}
+
+void settingText(const Settings& settings, SettingItem item, char* out, size_t outSize) {
+    static const char units[3][9] = {"Metric", "Imperial", "Nautical"};
+    static const char coordinates[3][18] = {"Degrees", "Deg. minutes", "Deg. min. seconds"};
+    switch (item) {
+        case SettingItem::Units:
+            snprintf(out, outSize, "Units: %s", units[static_cast<int>(settings.units)]);
+            break;
+        case SettingItem::Coordinates:
+            snprintf(out, outSize, "Coordinates: %s", coordinates[static_cast<int>(settings.coordinateFormat)]);
+            break;
+        case SettingItem::Night:
+            snprintf(out, outSize, "Night mode: %s", settings.nightMode ? "on" : "off");
+            break;
+        case SettingItem::Back:
+            snprintf(out, outSize, "< Back");
+            break;
+    }
+}
+
+void onSettingItem(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    const auto item = static_cast<SettingItem>(itemId(event));
+    Settings settings = ui->settings;
+    switch (item) {
+        case SettingItem::Units:
+            settings.units = static_cast<Units>((static_cast<int>(settings.units) + 1) % 3);
+            break;
+        case SettingItem::Coordinates:
+            settings.coordinateFormat = static_cast<CoordinateFormat>((static_cast<int>(settings.coordinateFormat) + 1) % 3);
+            break;
+        case SettingItem::Night:
+            settings.nightMode = !settings.nightMode;
+            break;
+        case SettingItem::Back:
+            closeOverlay(*ui);
+            return;
+    }
+    applySettings(*ui, settings);
+    if (item == SettingItem::Night) {
+        ui->rebuildPending = true;
+    }
+    char text[48];
+    settingText(settings, item, text, sizeof(text));
+    lv_obj_t* label = lv_obj_get_child(lv_event_get_current_target_obj(event), 0);
+    if (label != nullptr) {
+        lv_label_set_text(label, text);
+    }
+}
+
+void openSettings(UiState& ui) {
+    lv_obj_t* list = createOverlay(ui, Overlay::Settings, "Settings");
+    lv_obj_t* first = nullptr;
+    for (int i = 0; i <= static_cast<int>(SettingItem::Back); i++) {
+        char text[48];
+        settingText(ui.settings, static_cast<SettingItem>(i), text, sizeof(text));
+        lv_obj_t* item = addOverlayItem(ui, list, text, onSettingItem, i);
+        if (first == nullptr) {
+            first = item;
+        }
+    }
+    lv_group_focus_obj(first);
+}
+
+void onMenuButton(lv_event_t* event) {
+    openMenu(*static_cast<UiState*>(lv_event_get_user_data(event)));
+}
+
+bool isKeyInput() {
+    lv_indev_t* indev = lv_indev_active();
+    return indev != nullptr && lv_indev_get_type(indev) != LV_INDEV_TYPE_POINTER;
+}
+
+// Selecting the Signal tab with keys moves the keys to its bars, as Left and Right on the tab row only move the focus
+void onTabButton(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_obj_t* button = lv_event_get_current_target_obj(event);
+    for (int i = 0; i < TAB_COUNT; i++) {
+        if (ui->tabButtons[i] == button) {
+            setTab(*ui, i);
+            if (i == TAB_SIGNAL && isKeyInput() && !ui->messageCard.shown()) {
+                lv_group_focus_obj(ui->content);
+                setSignalScrolling(*ui, true);
+            }
+        }
+    }
+}
+
+void moveTab(UiState& ui, int direction) {
+    if (ui.signalScrolling) {
+        ui.signalTab.scroll(direction);
+        return;
+    }
+    setTab(ui, ui.activeTab + direction);
+}
+
+// Keys reach the content area while it has the focus. Letter keys are shortcuts only, every
+// action is also in the Enter menu.
+void onContentKey(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    const uint32_t key = lv_event_get_key(event);
+    switch (key) {
+        case LV_KEY_ESC:
+        case LV_KEY_BACKSPACE:
+            if (ui->signalScrolling) {
+                setSignalScrolling(*ui, false);
+            }
+            break;
+        case LV_KEY_LEFT:
+        case ',':
+            moveTab(*ui, -1);
+            break;
+        case LV_KEY_RIGHT:
+        case '.':
+        case ' ':
+            moveTab(*ui, 1);
+            break;
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+            setTab(*ui, static_cast<int>(key - '1'));
+            break;
+        case 'n':
+        case 'N':
+            toggleNight(*ui);
+            break;
+        case 'r':
+        case 'R':
+            requestBits(*ui, REQUEST_RESET_SPEED);
+            break;
+        case 's':
+        case 'S':
+            openSettings(*ui);
+            break;
+        case 'm':
+        case 'M':
+            openMenu(*ui);
+            break;
+        case 'l':
+        case 'L':
+            toggleRecording(*ui);
+            break;
+        default:
+            break;
+    }
+}
+
+// Enter from a keyboard, trackball or encoder opens the menu. Taps on the content don't.
+// Enter opens the action menu, and on the Signal tab it switches between scrolling the bars and switching tabs
+void onContentClicked(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    if (!isKeyInput()) {
+        return;
+    }
+    if (ui->activeTab == TAB_SIGNAL && !ui->messageCard.shown()) {
+        setSignalScrolling(*ui, !ui->signalScrolling);
+        return;
+    }
+    openMenu(*ui);
+}
+
+void onContentDefocused(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    if (ui->signalScrolling) {
+        setSignalScrolling(*ui, false);
+    }
+}
+
+void onContentGesture(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    lv_indev_t* indev = lv_indev_active();
+    if (indev == nullptr || ui->overlayType != Overlay::None) {
+        return;
+    }
+    // Widgets with event bubbling pass their own gestures up too. One that turned off gesture bubbling,
+    // like the dragged Signal bars, handles the swipe itself.
+    lv_obj_t* target = lv_event_get_target_obj(event);
+    if (target != ui->content && !lv_obj_is_gesture_bubble(target)) {
+        return;
+    }
+    const lv_dir_t direction = lv_indev_get_gesture_dir(indev);
+    if (direction == LV_DIR_LEFT) {
+        setTab(*ui, ui->activeTab + 1);
+    } else if (direction == LV_DIR_RIGHT) {
+        setTab(*ui, ui->activeTab - 1);
+    }
+}
+
+
+void onTimer(lv_timer_t* timer) {
+    auto* ui = static_cast<UiState*>(lv_timer_get_user_data(timer));
+    if (ui->rebuildPending && ui->overlayType == Overlay::None) {
+        ui->rebuildPending = false;
+        build(*ui);
+        return;
+    }
+    refresh(*ui);
+}
+
+lv_obj_t* createPanel(lv_obj_t* parent) {
+    lv_obj_t* panel = lv_obj_create(parent);
+    lv_obj_set_size(panel, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_style_bg_opa(panel, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_set_style_border_width(panel, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(panel, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(panel, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(panel, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_remove_flag(panel, LV_OBJ_FLAG_CLICK_FOCUSABLE);
+    lv_obj_add_flag(panel, LV_OBJ_FLAG_EVENT_BUBBLE);
+    return panel;
+}
+
+void clearTabs(UiState& ui) {
+    ui.statusTab.clear();
+    ui.signalTab.clear();
+    ui.skyTab.clear();
+    ui.positionTab.clear();
+}
+
+void forgetWidgets(UiState& ui) {
+    releaseOverlayGroup(ui);
+    if (ui.timer != nullptr) {
+        lv_timer_delete(ui.timer);
+        ui.timer = nullptr;
+    }
+    clearTabs(ui);
+    ui.messageCard.clear();
+    ui.header = nullptr;
+    ui.headerBadge = nullptr;
+    ui.badgeColor = 0;
+    ui.content = nullptr;
+    ui.signalScrolling = false;
+    ui.overlay = nullptr;
+    ui.overlayType = Overlay::None;
+    for (int i = 0; i < TAB_COUNT; i++) {
+        ui.tabButtons[i] = nullptr;
+        ui.tabIndicators[i] = nullptr;
+        ui.panels[i] = nullptr;
+    }
+}
+
+void onCloseButton(lv_event_t* event) {
+    auto* ui = static_cast<UiState*>(lv_event_get_user_data(event));
+    app_event_emit_close(ui->context->appInstanceId);
+}
+
+void onOpenLocationSettings(lv_event_t* event) {
+    requestBits(*static_cast<UiState*>(lv_event_get_user_data(event)), REQUEST_OPEN_LOCATION_SETTINGS);
+}
+
+void onBadgeButton(lv_event_t* event) {
+    setTab(*static_cast<UiState*>(lv_event_get_user_data(event)), TAB_STATUS);
+}
+
+// Night mode paints the toolbar like the rest of the app
+void paintNight(lv_obj_t* object, const Theme& theme) {
+    lv_obj_set_style_text_color(object, theme.text, LV_PART_MAIN);
+    const uint32_t count = lv_obj_get_child_count(object);
+    for (uint32_t i = 0; i < count; i++) {
+        paintNight(lv_obj_get_child(object, static_cast<int32_t>(i)), theme);
+    }
+}
+
+void createHeader(UiState& ui) {
+    ui.header = lvgl_toolbar_create(ui.root, "GPS Viewer");
+    lvgl_toolbar_set_nav_action(ui.header, LV_SYMBOL_CLOSE, onCloseButton, &ui);
+    // Fix state, filled in by updateHeader(). Opens the Status tab.
+    lv_obj_t* badge = lvgl_toolbar_add_text_button_action(ui.header, "", onBadgeButton, &ui);
+    // Action buttons are square, this one holds text
+    lv_obj_set_width(badge, LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_hor(badge, LV_DPX(4), LV_PART_MAIN);
+    ui.headerBadge = lv_obj_get_child(badge, 0);
+    if (ui.headerBadge != nullptr) {
+        lv_obj_set_style_text_font(ui.headerBadge, lvgl_get_text_font(FONT_SIZE_SMALL), LV_PART_MAIN);
+    }
+    lv_obj_t* menu = lvgl_toolbar_add_text_button_action(ui.header, LVGL_ICON_SHARED_MORE_VERT, onMenuButton, &ui);
+    lv_obj_set_style_text_font(menu, lvgl_get_shared_icon_default_font(), LV_PART_MAIN);
+    if (ui.theme.night) {
+        lv_obj_set_style_bg_color(ui.header, ui.theme.background, LV_PART_MAIN);
+        paintNight(ui.header, ui.theme);
+    }
+    ui.badgeColor = 0;
+}
+
+// Text tabs with a 2 px line under the active one. The strip is a grid navigation row, so the arrow keys and
+// encoders reach the tabs, and Enter selects the focused one.
+void createTabStrip(UiState& ui) {
+    const Theme& theme = ui.theme;
+    lv_obj_t* strip = createBox(ui.root);
+    lv_obj_set_size(strip, LV_PCT(100), LV_SIZE_CONTENT);
+    lv_obj_set_flex_flow(strip, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_border_color(strip, theme.border, LV_PART_MAIN);
+    lv_obj_set_style_border_width(strip, 1, LV_PART_MAIN);
+    lv_obj_set_style_border_side(strip, LV_BORDER_SIDE_BOTTOM, LV_PART_MAIN);
+    for (int i = 0; i < TAB_COUNT; i++) {
+        lv_obj_t* button = createBox(strip);
+        lv_obj_set_size(button, LV_PCT(25), LV_DPX(24));
+        lv_obj_add_flag(button, LV_OBJ_FLAG_CLICKABLE);
+        lv_obj_add_flag(button, LV_OBJ_FLAG_CLICK_FOCUSABLE);
+        lv_obj_set_style_outline_color(button, theme.accent, LV_STATE_FOCUS_KEY);
+        lv_obj_set_style_outline_width(button, 2, LV_STATE_FOCUS_KEY);
+        lv_obj_set_style_outline_pad(button, -2, LV_STATE_FOCUS_KEY);
+        lv_obj_remove_flag(button, LV_OBJ_FLAG_EVENT_BUBBLE);
+        lv_obj_remove_flag(button, LV_OBJ_FLAG_GESTURE_BUBBLE);
+        lv_obj_t* label = createLabel(button, FONT_SIZE_SMALL, theme.dim);
+        lv_label_set_text(label, TAB_NAMES[i]);
+        lv_obj_center(label);
+        lv_obj_t* indicator = createBox(button);
+        lv_obj_set_size(indicator, LV_PCT(70), 2);
+        lv_obj_align(indicator, LV_ALIGN_BOTTOM_MID, 0, 0);
+        lv_obj_set_style_bg_color(indicator, theme.accent, LV_PART_MAIN);
+        lv_obj_set_style_bg_opa(indicator, LV_OPA_COVER, LV_PART_MAIN);
+        lv_obj_add_flag(indicator, LV_OBJ_FLAG_FLOATING);
+        lv_obj_add_event_cb(button, onTabButton, LV_EVENT_CLICKED, &ui);
+        ui.tabButtons[i] = button;
+        ui.tabIndicators[i] = indicator;
+    }
+    lvgl_grid_navigation_add(strip);
+}
+
+void build(UiState& ui) {
+    forgetWidgets(ui);
+    lv_obj_clean(ui.root);
+    {
+        ContextLock lock(*ui.context);
+        ui.settings = ui.context->settings;
+    }
+    ui.theme = makeTheme(ui.settings.nightMode);
+    lv_obj_t* root = ui.root;
+
+    // The night background is a style of a user state of the window's widget. Leaving night mode clears
+    // the state, and the window's own background is back (lv_obj_remove_local_style_prop() is not exported).
+    if (ui.theme.paintBackground) {
+        lv_obj_set_style_bg_color(root, ui.theme.background, NIGHT_SELECTOR);
+        lv_obj_set_style_bg_opa(root, LV_OPA_COVER, NIGHT_SELECTOR);
+        lv_obj_add_state(root, NIGHT_STATE);
+    } else {
+        lv_obj_remove_state(root, NIGHT_STATE);
+    }
+    lv_obj_set_flex_flow(root, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_row(root, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(root, LV_OBJ_FLAG_SCROLLABLE);
+
+    createHeader(ui);
+    createTabStrip(ui);
+
+    ui.content = lv_obj_create(root);
+    lv_obj_set_width(ui.content, LV_PCT(100));
+    lv_obj_set_flex_grow(ui.content, 1);
+    lv_obj_set_style_bg_opa(ui.content, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_set_style_border_width(ui.content, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(ui.content, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(ui.content, LV_DPX(4), LV_PART_MAIN);
+    lv_obj_set_style_outline_width(ui.content, 0, LV_STATE_FOCUS_KEY);
+    lv_obj_set_style_outline_width(ui.content, 0, LV_STATE_FOCUSED);
+    lv_obj_remove_flag(ui.content, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_add_event_cb(ui.content, onContentKey, LV_EVENT_KEY, &ui);
+    lv_obj_add_event_cb(ui.content, onContentClicked, LV_EVENT_CLICKED, &ui);
+    lv_obj_add_event_cb(ui.content, onContentDefocused, LV_EVENT_DEFOCUSED, &ui);
+    lv_obj_add_event_cb(ui.content, onContentGesture, LV_EVENT_GESTURE, &ui);
+    lv_obj_update_layout(root);
+
+    for (int i = 0; i < TAB_COUNT; i++) {
+        ui.panels[i] = createPanel(ui.content);
+    }
+    // The tabs size their widgets from the panel size
+    lv_obj_update_layout(ui.content);
+    ui.positionTab.create(ui.panels[TAB_POSITION], ui.theme);
+    ui.skyTab.create(ui.panels[TAB_SKY], ui.theme);
+    ui.signalTab.create(ui.panels[TAB_SIGNAL], ui.theme);
+    ui.statusTab.create(ui.panels[TAB_STATUS], ui.theme);
+    ui.messageCard.create(ui.content, ui.theme, onOpenLocationSettings, onContentKey, &ui);
+
+    lv_group_t* group = lv_group_get_default();
+    if (group != nullptr) {
+        lv_group_add_obj(group, ui.content);
+        lv_group_focus_obj(ui.content);
+    }
+
+    styleTabButtons(ui);
+    ui.timer = lv_timer_create(onTimer, REFRESH_MS, &ui);
+    refresh(ui);
+}
+
+void refresh(UiState& ui) {
+    if (ui.content == nullptr) {
+        return;
+    }
+    SourceStatus status;
+    bool recording;
+    {
+        ContextLock lock(*ui.context);
+        ui.context->model.snapshot(ui.snapshot, get_millis());
+        status = ui.context->status;
+        memcpy(ui.receiverName, ui.context->receiverName, sizeof(ui.receiverName));
+        ui.settings = ui.context->settings;
+        recording = ui.context->recording;
+        ui.recordedLines = ui.context->recordedLines;
+    }
+    ui.status = status;
+    ui.recording = recording;
+    updateHeader(ui);
+
+    const bool wasShown = ui.messageCard.shown();
+    const bool hadButton = wasShown && ui.messageCard.focusTarget() != nullptr &&
+                           !lv_obj_has_flag(ui.messageCard.focusTarget(), LV_OBJ_FLAG_HIDDEN);
+    const bool showMessage = ui.messageCard.update(ui.status, ui.context->dataDirectory);
+    const bool hasButton = showMessage && !lv_obj_has_flag(ui.messageCard.focusTarget(), LV_OBJ_FLAG_HIDDEN);
+    if ((wasShown != showMessage || hadButton != hasButton) && ui.overlayType == Overlay::None) {
+        focusMain(ui);
+    }
+    for (int i = 0; i < TAB_COUNT; i++) {
+        setHidden(ui.panels[i], i != ui.activeTab || showMessage);
+    }
+    if (showMessage) {
+        return;
+    }
+
+    const TabView view {ui.snapshot, ui.settings, ui.status, ui.recording, ui.receiverName, ui.theme};
+    switch (ui.activeTab) {
+        case TAB_POSITION: ui.positionTab.update(view); break;
+        case TAB_SKY: ui.skyTab.update(view); break;
+        case TAB_SIGNAL: ui.signalTab.update(view); break;
+        default: ui.statusTab.update(view); break;
+    }
+}
+
+} // namespace
+
+UiState* uiAllocate(AppContext& context) {
+    auto* ui = tt::newObject<UiState>();
+    if (ui != nullptr) {
+        ui->context = &context;
+    }
+    return ui;
+}
+
+void uiFree(UiState* ui) {
+    if (ui != nullptr) {
+        tt::deleteObject(ui);
+    }
+}
+
+void uiCreateWidgets(lv_obj_t* root, void* userData) {
+    auto* context = static_cast<AppContext*>(userData);
+    UiState& ui = *context->ui;
+    ui.root = root;
+    build(ui);
+}
+
+void setNightMode(AppContext& context, bool enable) {
+    if (context.ui != nullptr) {
+        setNightMode(*context.ui, enable);
+    }
+}
+
+void uiDestroyWidgets(void* userData) {
+    auto* context = static_cast<AppContext*>(userData);
+    UiState& ui = *context->ui;
+    forgetWidgets(ui);
+    ui.root = nullptr;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Ui.h b/Apps/GpsViewer/main/Source/app/Ui.h
new file mode 100644
index 0000000..9ff4521
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Ui.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "AppContext.h"
+
+#include <lvgl.h>
+
+namespace gpsviewer {
+
+UiState* uiAllocate(AppContext& context);
+void uiFree(UiState* ui);
+
+// window_manager_create_ext() callbacks, user_data is the AppContext
+void uiCreateWidgets(lv_obj_t* root, void* userData);
+void uiDestroyWidgets(void* userData);
+
+// Switches between the normal dark and the tactical red palette. Stores the choice and rebuilds the
+// widget tree. LVGL thread only.
+void setNightMode(AppContext& context, bool enable);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Widgets.cpp b/Apps/GpsViewer/main/Source/app/Widgets.cpp
new file mode 100644
index 0000000..149c8bd
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Widgets.cpp
@@ -0,0 +1,409 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "Widgets.h"
+
+#include <cmath>
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr int MAX_POINTS = 10;
+constexpr float PI_F = 3.14159265f;
+
+// lv_obj_get_style_*_color are not exported to apps, so the icon keeps its colours in the user data
+uintptr_t packColor(lv_color_t color) {
+    return (static_cast<uintptr_t>(color.red) << 16) | (static_cast<uintptr_t>(color.green) << 8) | color.blue;
+}
+
+lv_color_t unpackColor(uintptr_t packed) {
+    lv_color_t color;
+    color.red = static_cast<uint8_t>(packed >> 16);
+    color.green = static_cast<uint8_t>(packed >> 8);
+    color.blue = static_cast<uint8_t>(packed);
+    return color;
+}
+
+// Width of one line of UTF-8 text, as lv_text_get_size() is not exported to apps
+int textWidth(const char* text, const lv_font_t* font) {
+    int width = 0;
+    const auto* bytes = reinterpret_cast<const unsigned char*>(text);
+    while (*bytes != 0) {
+        uint32_t letter = *bytes++;
+        int extra = 0;
+        if (letter >= 0xF0) {
+            letter &= 0x07;
+            extra = 3;
+        } else if (letter >= 0xE0) {
+            letter &= 0x0F;
+            extra = 2;
+        } else if (letter >= 0xC0) {
+            letter &= 0x1F;
+            extra = 1;
+        }
+        for (; extra > 0 && (*bytes & 0xC0) == 0x80; extra--) {
+            letter = (letter << 6) | (*bytes++ & 0x3F);
+        }
+        width += lv_font_get_glyph_width(font, letter, *bytes);
+    }
+    return width;
+}
+
+int roundInt(float value) {
+    return static_cast<int>(std::floor(value + 0.5f));
+}
+
+void drawIcon(lv_event_t* event) {
+    lv_obj_t* object = lv_event_get_current_target_obj(event);
+    lv_layer_t* layer = lv_event_get_layer(event);
+    const auto packed = reinterpret_cast<uintptr_t>(lv_obj_get_user_data(object));
+    const auto kind = static_cast<IconKind>(packed >> 24);
+    const lv_color_t color = unpackColor(packed & 0xFFFFFFU);
+    lv_area_t area;
+    lv_obj_get_coords(object, &area);
+    const int size = area.x2 - area.x1 + 1;
+    const float cx = static_cast<float>(area.x1) + static_cast<float>(size - 1) / 2.0f;
+    const float cy = static_cast<float>(area.y1) + static_cast<float>(size - 1) / 2.0f;
+    const float half = static_cast<float>(size) / 2.0f;
+    switch (kind) {
+        case IconKind::Sun: {
+            drawCircle(layer, roundInt(cx), roundInt(cy), roundInt(half * 0.4f + 0.5f), color, true);
+            for (int i = 0; i < 8; i++) {
+                const float angle = static_cast<float>(i) * PI_F / 4.0f;
+                const float c = std::cos(angle);
+                const float s = std::sin(angle);
+                drawLine(layer, roundInt(cx + c * half * 0.65f), roundInt(cy + s * half * 0.65f),
+                         roundInt(cx + c * (half - 0.5f)), roundInt(cy + s * (half - 0.5f)), color);
+            }
+            break;
+        }
+        case IconKind::Moon: {
+            const lv_color_t surface = unpackColor(reinterpret_cast<uintptr_t>(lv_event_get_user_data(event)));
+            drawCircle(layer, roundInt(cx), roundInt(cy), roundInt(half * 0.85f), color, true);
+            drawCircle(layer, roundInt(cx + half * 0.5f), roundInt(cy - half * 0.3f), roundInt(half * 0.7f), surface, true);
+            break;
+        }
+        case IconKind::Alert: {
+            const float xs[3] = {cx, cx + half - 0.5f, cx - half + 0.5f};
+            const float ys[3] = {cy - half + 1.0f, cy + half - 1.5f, cy + half - 1.5f};
+            for (int i = 0; i < 3; i++) {
+                const int j = (i + 1) % 3;
+                drawLine(layer, roundInt(xs[i]), roundInt(ys[i]), roundInt(xs[j]), roundInt(ys[j]), color, 2);
+            }
+            // Exclamation mark: bar and dot
+            const int x = roundInt(cx);
+            const int top = roundInt(cy - half * 0.35f);
+            const int bottom = roundInt(cy + half * 0.2f);
+            drawFilledRect(layer, x - 1, top, x, bottom, color);
+            drawFilledRect(layer, x - 1, bottom + 3, x, bottom + 4, color);
+            break;
+        }
+    }
+}
+
+} // namespace
+
+int measureTextWidth(const char* text, const lv_font_t* font) {
+    return textWidth(text, font);
+}
+
+lv_obj_t* createBox(lv_obj_t* parent) {
+    lv_obj_t* box = lv_obj_create(parent);
+    lv_obj_set_style_bg_opa(box, LV_OPA_TRANSP, LV_PART_MAIN);
+    lv_obj_set_style_border_width(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_outline_width(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_shadow_width(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_row(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_column(box, 0, LV_PART_MAIN);
+    lv_obj_set_style_radius(box, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_CLICK_FOCUSABLE);
+    lv_obj_remove_flag(box, LV_OBJ_FLAG_SCROLL_CHAIN);
+    lv_obj_add_flag(box, LV_OBJ_FLAG_EVENT_BUBBLE);
+    lv_obj_add_flag(box, LV_OBJ_FLAG_GESTURE_BUBBLE);
+    if (lv_group_get_default() != nullptr) {
+        lv_group_remove_obj(box);
+    }
+    return box;
+}
+
+lv_obj_t* createSection(lv_obj_t* parent) {
+    lv_obj_t* section = createBox(parent);
+    lv_obj_set_style_pad_all(section, LV_DPX(4), LV_PART_MAIN);
+    return section;
+}
+
+void setDivider(lv_obj_t* object, const Theme& theme, lv_border_side_t side) {
+    lv_obj_set_style_border_color(object, theme.border, LV_PART_MAIN);
+    lv_obj_set_style_border_width(object, 1, LV_PART_MAIN);
+    lv_obj_set_style_border_side(object, side, LV_PART_MAIN);
+}
+
+lv_obj_t* createLabel(lv_obj_t* parent, LvglFontSize size, lv_color_t color) {
+    lv_obj_t* label = lv_label_create(parent);
+    lv_label_set_long_mode(label, LV_LABEL_LONG_CLIP);
+    lv_obj_set_style_text_font(label, lvgl_get_text_font(size), LV_PART_MAIN);
+    lv_obj_set_style_text_color(label, color, LV_PART_MAIN);
+    lv_label_set_text(label, "");
+    return label;
+}
+
+lv_obj_t* createCaption(lv_obj_t* parent, const Theme& theme, const char* text) {
+    lv_obj_t* label = createLabel(parent, FONT_SIZE_SMALL, theme.dim);
+    lv_label_set_text(label, text);
+    return label;
+}
+
+lv_obj_t* createTag(lv_obj_t* parent, const char* text, lv_color_t color) {
+    lv_obj_t* tag = createLabel(parent, FONT_SIZE_SMALL, color);
+    lv_label_set_text(tag, text);
+    return tag;
+}
+
+void setHidden(lv_obj_t* object, bool hidden) {
+    if (object == nullptr) {
+        return;
+    }
+    if (hidden == lv_obj_has_flag(object, LV_OBJ_FLAG_HIDDEN)) {
+        return;
+    }
+    if (hidden) {
+        lv_obj_add_flag(object, LV_OBJ_FLAG_HIDDEN);
+    } else {
+        lv_obj_remove_flag(object, LV_OBJ_FLAG_HIDDEN);
+    }
+}
+
+void setFittedText(lv_obj_t* label, const char* text, int maxWidth) {
+    if (label == nullptr || strcmp(lv_label_get_text(label), text) == 0) {
+        return;
+    }
+    const LvglFontSize sizes[3] = {FONT_SIZE_LARGE, FONT_SIZE_DEFAULT, FONT_SIZE_SMALL};
+    const lv_font_t* font = lvgl_get_text_font(FONT_SIZE_SMALL);
+    for (int i = 0; i < 3; i++) {
+        font = lvgl_get_text_font(sizes[i]);
+        if (textWidth(text, font) <= maxWidth) {
+            break;
+        }
+    }
+    lv_obj_set_style_text_font(label, font, LV_PART_MAIN);
+    lv_label_set_text(label, text);
+}
+
+lv_obj_t* createIcon(lv_obj_t* parent, IconKind kind, int size, lv_color_t color, lv_color_t surface) {
+    lv_obj_t* icon = createBox(parent);
+    lv_obj_set_size(icon, size, size);
+    const uintptr_t packed = (static_cast<uintptr_t>(kind) << 24) | packColor(color);
+    lv_obj_set_user_data(icon, reinterpret_cast<void*>(packed));
+    lv_obj_add_event_cb(icon, drawIcon, LV_EVENT_DRAW_MAIN, reinterpret_cast<void*>(packColor(surface)));
+    return icon;
+}
+
+void drawText(lv_layer_t* layer, const char* text, const lv_font_t* font, lv_color_t color, const lv_area_t& area,
+              lv_text_align_t align) {
+    lv_draw_label_dsc_t dsc;
+    lv_draw_label_dsc_init(&dsc);
+    dsc.font = font;
+    dsc.color = color;
+    dsc.text = text;
+    dsc.text_local = 1;
+    dsc.align = align;
+    lv_draw_label(layer, &dsc, &area);
+}
+
+void drawLine(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int width) {
+    lv_draw_line_dsc_t dsc;
+    lv_draw_line_dsc_init(&dsc);
+    dsc.color = color;
+    dsc.width = width;
+    dsc.p1.x = x1;
+    dsc.p1.y = y1;
+    dsc.p2.x = x2;
+    dsc.p2.y = y2;
+    lv_draw_line(layer, &dsc);
+}
+
+void drawCircle(lv_layer_t* layer, int cx, int cy, int radius, lv_color_t color, bool filled, int borderWidth) {
+    lv_area_t box;
+    box.x1 = cx - radius;
+    box.y1 = cy - radius;
+    box.x2 = cx + radius;
+    box.y2 = cy + radius;
+    lv_draw_rect_dsc_t rect;
+    lv_draw_rect_dsc_init(&rect);
+    rect.radius = LV_RADIUS_CIRCLE;
+    if (filled) {
+        rect.bg_opa = LV_OPA_COVER;
+        rect.bg_color = color;
+        rect.border_width = 0;
+    } else {
+        rect.bg_opa = LV_OPA_TRANSP;
+        rect.border_opa = LV_OPA_COVER;
+        rect.border_color = color;
+        rect.border_width = borderWidth;
+        rect.border_side = LV_BORDER_SIDE_FULL;
+    }
+    lv_draw_rect(layer, &rect, &box);
+}
+
+void drawFilledRect(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int radius) {
+    lv_area_t box;
+    box.x1 = x1;
+    box.y1 = y1;
+    box.x2 = x2;
+    box.y2 = y2;
+    lv_draw_rect_dsc_t rect;
+    lv_draw_rect_dsc_init(&rect);
+    rect.radius = radius;
+    rect.bg_opa = LV_OPA_COVER;
+    rect.bg_color = color;
+    rect.border_width = 0;
+    lv_draw_rect(layer, &rect, &box);
+}
+
+// Even-odd scanline fill, works for convex and concave outlines
+void fillPolygon(lv_layer_t* layer, const float* px, const float* py, int n, lv_color_t color) {
+    float top = py[0];
+    float bottom = py[0];
+    for (int i = 1; i < n; i++) {
+        if (py[i] < top) {
+            top = py[i];
+        }
+        if (py[i] > bottom) {
+            bottom = py[i];
+        }
+    }
+    lv_draw_fill_dsc_t fill;
+    lv_draw_fill_dsc_init(&fill);
+    fill.color = color;
+    fill.radius = 0;
+    const int yStart = static_cast<int>(std::floor(top));
+    const int yEnd = static_cast<int>(std::ceil(bottom));
+    for (int y = yStart; y <= yEnd; y++) {
+        const float yc = static_cast<float>(y) + 0.5f;
+        float xs[MAX_POINTS];
+        int m = 0;
+        for (int i = 0; i < n; i++) {
+            const int j = (i + 1) % n;
+            const float lo = py[i] < py[j] ? py[i] : py[j];
+            const float hi = py[i] < py[j] ? py[j] : py[i];
+            if (hi > lo && yc >= lo && yc < hi && m < MAX_POINTS) {
+                xs[m++] = px[i] + (yc - py[i]) * (px[j] - px[i]) / (py[j] - py[i]);
+            }
+        }
+        for (int i = 1; i < m; i++) {
+            const float value = xs[i];
+            int j = i;
+            while (j > 0 && xs[j - 1] > value) {
+                xs[j] = xs[j - 1];
+                j--;
+            }
+            xs[j] = value;
+        }
+        for (int i = 0; i + 1 < m; i += 2) {
+            lv_area_t span;
+            span.x1 = roundInt(xs[i]);
+            span.x2 = roundInt(xs[i + 1]) - 1;
+            if (span.x2 < span.x1) {
+                span.x2 = span.x1;
+            }
+            span.y1 = y;
+            span.y2 = y;
+            lv_draw_fill(layer, &fill, &span);
+        }
+    }
+}
+
+void drawMarker(lv_layer_t* layer, GnssSystem system, float cx, float cy, float radius, bool filled, lv_color_t color) {
+    const float r = radius;
+    float xs[MAX_POINTS];
+    float ys[MAX_POINTS];
+    int n = 0;
+    switch (system) {
+        case GnssSystem::Gps:
+            drawCircle(layer, roundInt(cx), roundInt(cy), roundInt(r), color, filled, 2);
+            return;
+        case GnssSystem::Glonass:
+            xs[n] = cx;
+            ys[n++] = cy - r * 1.15f;
+            xs[n] = cx + r * 1.1f;
+            ys[n++] = cy + r * 0.85f;
+            xs[n] = cx - r * 1.1f;
+            ys[n++] = cy + r * 0.85f;
+            break;
+        case GnssSystem::Galileo:
+            for (int i = 0; i < 5; i++) {
+                const float angle = (-90.0f + 72.0f * static_cast<float>(i)) * PI_F / 180.0f;
+                xs[n] = cx + r * 1.05f * std::cos(angle);
+                ys[n++] = cy + r * 1.05f * std::sin(angle);
+            }
+            break;
+        case GnssSystem::Beidou:
+            for (int i = 0; i < 10; i++) {
+                const float angle = (-90.0f + 36.0f * static_cast<float>(i)) * PI_F / 180.0f;
+                const float radiusI = (i % 2 == 0) ? r * 1.2f : r * 0.5f;
+                xs[n] = cx + radiusI * std::cos(angle);
+                ys[n++] = cy + radiusI * std::sin(angle);
+            }
+            break;
+        case GnssSystem::Qzss:
+        case GnssSystem::Sbas: {
+            const float h = r * 0.85f;
+            xs[n] = cx - h;
+            ys[n++] = cy - h;
+            xs[n] = cx + h;
+            ys[n++] = cy - h;
+            xs[n] = cx + h;
+            ys[n++] = cy + h;
+            xs[n] = cx - h;
+            ys[n++] = cy + h;
+            break;
+        }
+        default:
+            xs[n] = cx;
+            ys[n++] = cy - r * 1.2f;
+            xs[n] = cx + r * 1.2f;
+            ys[n++] = cy;
+            xs[n] = cx;
+            ys[n++] = cy + r * 1.2f;
+            xs[n] = cx - r * 1.2f;
+            ys[n++] = cy;
+            break;
+    }
+    if (filled) {
+        fillPolygon(layer, xs, ys, n, color);
+        return;
+    }
+    for (int i = 0; i < n; i++) {
+        const int j = (i + 1) % n;
+        drawLine(layer, roundInt(xs[i]), roundInt(ys[i]), roundInt(xs[j]), roundInt(ys[j]), color);
+    }
+}
+
+lv_color_t fixColor(FixType fix, const Theme& theme) {
+    if (fix == FixType::Fix3d) {
+        return theme.success;
+    }
+    return fix == FixType::Fix2d ? theme.warning : theme.dim;
+}
+
+const char* fixText(FixType fix) {
+    return fix == FixType::Fix3d ? "3D FIX" : (fix == FixType::Fix2d ? "2D FIX" : "NO FIX");
+}
+
+const char* systemShortName(GnssSystem system) {
+    switch (system) {
+        case GnssSystem::Gps: return "GPS";
+        case GnssSystem::Glonass: return "GLO";
+        case GnssSystem::Galileo: return "GAL";
+        case GnssSystem::Beidou: return "BDS";
+        case GnssSystem::Qzss: return "QZS";
+        case GnssSystem::Sbas: return "SBS";
+        case GnssSystem::Navic: return "NIC";
+        default: return "UNK";
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/app/Widgets.h b/Apps/GpsViewer/main/Source/app/Widgets.h
new file mode 100644
index 0000000..fbec711
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/app/Widgets.h
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Tabs.h"
+
+#include <lvgl.h>
+#include <lvgl/fonts.h>
+
+namespace gpsviewer {
+
+// Widgets: all use local styles only, the platform has no shared style descriptors
+
+// Transparent container without border, padding, scrolling or input
+lv_obj_t* createBox(lv_obj_t* parent);
+// Flat group of widgets with a little padding, no background or border
+lv_obj_t* createSection(lv_obj_t* parent);
+// 1 px line in the divider colour on the given sides of the object
+void setDivider(lv_obj_t* object, const Theme& theme, lv_border_side_t side);
+lv_obj_t* createLabel(lv_obj_t* parent, LvglFontSize size, lv_color_t color);
+// Small dim label above a value
+lv_obj_t* createCaption(lv_obj_t* parent, const Theme& theme, const char* text);
+// Small coloured label for a state, e.g. REC
+lv_obj_t* createTag(lv_obj_t* parent, const char* text, lv_color_t color);
+void setHidden(lv_obj_t* object, bool hidden);
+// Sets the text in the largest of the LARGE, DEFAULT and SMALL fonts that fits maxWidth, only
+// when the text differs
+void setFittedText(lv_obj_t* label, const char* text, int maxWidth);
+// Width of one line of text in the font
+int measureTextWidth(const char* text, const lv_font_t* font);
+
+enum class IconKind : uint8_t {
+    Sun,
+    Moon,
+    Alert,
+};
+// Square icon drawn with the draw calls. Its text colour is the icon colour, its background
+// colour (not painted) is the colour of the surface behind it, used to cut out the moon.
+lv_obj_t* createIcon(lv_obj_t* parent, IconKind kind, int size, lv_color_t color, lv_color_t surface);
+
+// Drawing, for LV_EVENT_DRAW_MAIN handlers
+void drawText(lv_layer_t* layer, const char* text, const lv_font_t* font, lv_color_t color, const lv_area_t& area,
+              lv_text_align_t align);
+void drawLine(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int width = 1);
+void drawCircle(lv_layer_t* layer, int cx, int cy, int radius, lv_color_t color, bool filled, int borderWidth = 1);
+void drawFilledRect(lv_layer_t* layer, int x1, int y1, int x2, int y2, lv_color_t color, int radius = 0);
+void fillPolygon(lv_layer_t* layer, const float* xs, const float* ys, int count, lv_color_t color);
+// Marker shapes: circle GPS, triangle GLONASS, pentagon Galileo, star BeiDou, square QZSS and SBAS,
+// diamond NavIC and unknown. The shape is about 2 * radius wide.
+void drawMarker(lv_layer_t* layer, GnssSystem system, float cx, float cy, float radius, bool filled, lv_color_t color);
+
+lv_color_t fixColor(FixType fix, const Theme& theme);
+// "3D FIX", "2D FIX" or "NO FIX"
+const char* fixText(FixType fix);
+// Short constellation name for tight spaces: "GPS", "GLO", "GAL", "BDS", "QZS", "SBS", "NIC", "UNK"
+const char* systemShortName(GnssSystem system);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Format.cpp b/Apps/GpsViewer/main/Source/core/Format.cpp
new file mode 100644
index 0000000..5a3dfeb
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Format.cpp
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "Format.h"
+
+#include <cmath>
+#include <cstdio>
+#include <limits>
+
+namespace gpsviewer {
+
+namespace {
+
+// llround() is not exported to Tactility apps
+long long lroundExported(double value) {
+    return static_cast<long long>(std::round(value));
+}
+
+float quietNaN() {
+    return std::numeric_limits<float>::quiet_NaN();
+}
+
+void writeDash(char* out, size_t outSize) {
+    std::snprintf(out, outSize, "--");
+}
+
+double speedFactor(Units units) {
+    switch (units) {
+        case Units::Imperial:
+            return 2.236936;
+        case Units::Nautical:
+            return 1.943844;
+        case Units::Metric:
+            break;
+    }
+    return 3.6;
+}
+
+double lengthFactor(Units units) {
+    return units == Units::Imperial ? 3.28084 : 1.0;
+}
+
+// One decimal below the limit, whole numbers from it on. The check uses the rounded value.
+void writeAdaptive(double value, double limit, const char* suffix, char* out, size_t outSize) {
+    if (std::round(value * 10.0) < limit * 10.0) {
+        std::snprintf(out, outSize, "%.1f%s", value, suffix);
+    } else {
+        std::snprintf(out, outSize, "%lld%s", static_cast<long long>(std::round(value)), suffix);
+    }
+}
+
+} // namespace
+
+float estimatedAccuracyMeters(float hdop) {
+    if (std::isnan(hdop) || hdop <= 0.0f) {
+        return quietNaN();
+    }
+    return hdop * 5.0f;
+}
+
+void formatCoordinate(double degrees, bool isLatitude, CoordinateFormat format, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(degrees)) {
+        writeDash(out, outSize);
+        return;
+    }
+
+    const bool negative = degrees < 0.0;
+    const char hemisphere = isLatitude ? (negative ? 'S' : 'N') : (negative ? 'W' : 'E');
+    const double absolute = std::fabs(degrees);
+
+    switch (format) {
+        case CoordinateFormat::Degrees:
+            std::snprintf(out, outSize, "%.5f\xC2\xB0 %c", absolute, hemisphere);
+            return;
+        case CoordinateFormat::DegreesMinutes: {
+            // Thousandths of a minute, rounded before splitting so carries propagate
+            const long long units = lroundExported(absolute * 60000.0);
+            const long long deg = units / 60000;
+            const long long rest = units % 60000;
+            std::snprintf(out, outSize, "%lld\xC2\xB0 %lld.%03lld' %c",
+                          deg, rest / 1000, rest % 1000, hemisphere);
+            return;
+        }
+        case CoordinateFormat::DegreesMinutesSeconds: {
+            // Tenths of a second, rounded before splitting so carries propagate
+            const long long tenths = lroundExported(absolute * 36000.0);
+            const long long deg = tenths / 36000;
+            const long long rest = tenths % 36000;
+            const long long minutes = rest / 600;
+            const long long rest2 = rest % 600;
+            std::snprintf(out, outSize, "%lld\xC2\xB0 %lld' %lld.%lld\" %c",
+                          deg, minutes, rest2 / 10, rest2 % 10, hemisphere);
+            return;
+        }
+    }
+}
+
+void formatSpeed(float metersPerSecond, Units units, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(metersPerSecond)) {
+        writeDash(out, outSize);
+        return;
+    }
+    writeAdaptive(static_cast<double>(metersPerSecond) * speedFactor(units), 100.0, "", out, outSize);
+}
+
+const char* speedUnit(Units units) {
+    switch (units) {
+        case Units::Imperial:
+            return "mph";
+        case Units::Nautical:
+            return "kn";
+        case Units::Metric:
+            break;
+    }
+    return "km/h";
+}
+
+void formatAltitude(float meters, Units units, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(meters)) {
+        writeDash(out, outSize);
+        return;
+    }
+    const double value = static_cast<double>(meters) * lengthFactor(units);
+    const char* suffix = units == Units::Imperial ? " ft" : " m";
+    std::snprintf(out, outSize, "%lld%s", static_cast<long long>(std::round(value)), suffix);
+}
+
+void formatAccuracy(float meters, Units units, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    if (std::isnan(meters)) {
+        writeDash(out, outSize);
+        return;
+    }
+    const double value = static_cast<double>(meters) * lengthFactor(units);
+    const char* suffix = units == Units::Imperial ? " ft" : " m";
+    writeAdaptive(value, 10.0, suffix, out, outSize);
+}
+
+void formatDuration(unsigned seconds, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return;
+    }
+    const unsigned hours = seconds / 3600U;
+    const unsigned minutes = (seconds / 60U) % 60U;
+    const unsigned secs = seconds % 60U;
+    if (hours > 0) {
+        std::snprintf(out, outSize, "%u:%02u:%02u", hours, minutes, secs);
+    } else {
+        std::snprintf(out, outSize, "%u:%02u", minutes, secs);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Format.h b/Apps/GpsViewer/main/Source/core/Format.h
new file mode 100644
index 0000000..0036d55
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Format.h
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include <cstddef>
+
+namespace gpsviewer {
+
+enum class Units {
+    Metric,
+    Imperial,
+    Nautical,
+};
+
+enum class CoordinateFormat {
+    Degrees,
+    DegreesMinutes,
+    DegreesMinutesSeconds,
+};
+
+// Estimated horizontal accuracy in meters: HDOP times 5 m. NMEA gives no real accuracy.
+float estimatedAccuracyMeters(float hdop);
+
+// Writes e.g. "47.49801° N", "47° 29.881' N" or "47° 29' 52.8\" N" (° is UTF-8)
+void formatCoordinate(double degrees, bool isLatitude, CoordinateFormat format, char* out, size_t outSize);
+
+// Speed number without unit, e.g. "12.3", and the unit "km/h", "mph" or "kn"
+void formatSpeed(float metersPerSecond, Units units, char* out, size_t outSize);
+const char* speedUnit(Units units);
+
+// Altitude and accuracy: "123 m" or "404 ft". Nautical uses meters.
+void formatAltitude(float meters, Units units, char* out, size_t outSize);
+void formatAccuracy(float meters, Units units, char* out, size_t outSize);
+
+// "1:05" for 65 s, "1:02:03" from one hour up
+void formatDuration(unsigned seconds, char* out, size_t outSize);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssModel.cpp b/Apps/GpsViewer/main/Source/core/GnssModel.cpp
new file mode 100644
index 0000000..57419b9
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssModel.cpp
@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "GnssModel.h"
+
+#include <cmath>
+
+namespace gpsviewer {
+
+namespace {
+
+// A fix source that went quiet for this long no longer counts
+constexpr uint32_t FIX_TIMEOUT_MS = 5000;
+
+bool olderThan(uint32_t nowMs, uint32_t thenMs, uint32_t ageMs) {
+    return static_cast<uint32_t>(nowMs - thenMs) > ageMs;
+}
+
+// A time of 0 means the sentence never came
+bool fresh(uint32_t nowMs, uint32_t atMs) {
+    return atMs != 0 && !olderThan(nowMs, atMs, FIX_TIMEOUT_MS);
+}
+
+// Event times are 0 only in the first millisecond of uptime, which then counts as never
+uint32_t stamp(uint32_t nowMs) {
+    return nowMs == 0 ? 1 : nowMs;
+}
+
+float toFloatOrNan(const minmea_float& value) {
+    return value.scale == 0 ? NAN : minmea_tofloat(&value);
+}
+
+// minmea_tocoord() returns a float, which loses about half a meter
+double toCoordinate(const minmea_float& value) {
+    if (value.scale == 0) {
+        return NAN;
+    }
+    const double raw = static_cast<double>(value.value) / value.scale;
+    const int degrees = static_cast<int>(raw / 100);
+    return degrees + (raw - degrees * 100) / 60.0;
+}
+
+} // namespace
+
+void GnssModel::reset(uint32_t nowMs) {
+    satellites.clear();
+    startMs = nowMs;
+    gsaFix = FixType::None;
+    gsaAtMs = 0;
+    ggaFix = false;
+    ggaSatellites = 0;
+    ggaAtMs = 0;
+    rmcValid = false;
+    rmcAtMs = 0;
+    pdop = NAN;
+    gsaHdop = NAN;
+    ggaHdop = NAN;
+    vdop = NAN;
+    hasTtff = false;
+    ttffMs = 0;
+    hasPosition = false;
+    hasAltitude = false;
+    hasSpeed = false;
+    maxSpeedMps = 0;
+    speedSum = 0;
+    speedSamples = 0;
+    utcTime = {};
+}
+
+void GnssModel::onEvent(const GnssEvent& event, uint32_t nowMs) {
+    switch (event.type) {
+        case GnssEventType::Rmc:
+            onRmc(event.data.rmc, nowMs);
+            break;
+        case GnssEventType::Gga:
+            onGga(event.data.gga, nowMs);
+            break;
+        case GnssEventType::Gsv:
+            satellites.onGsv(event.talker, event.data.gsv, nowMs);
+            break;
+        case GnssEventType::Gsa:
+            satellites.onGsa(event.talker, event.data.gsa, nowMs);
+            onGsa(event.data.gsa, nowMs);
+            break;
+    }
+    updateFixState(nowMs);
+}
+
+void GnssModel::onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs) {
+    rmcValid = rmc.valid;
+    rmcAtMs = stamp(nowMs);
+    if (rmc.date.year > 0 && rmc.time.hours >= 0) {
+        utcTime.valid = true;
+        utcTime.year = rmc.date.year < 100 ? 2000 + rmc.date.year : rmc.date.year;
+        utcTime.month = rmc.date.month;
+        utcTime.day = rmc.date.day;
+        utcTime.hour = rmc.time.hours;
+        utcTime.minute = rmc.time.minutes;
+        utcTime.second = rmc.time.seconds;
+    }
+    if (!rmc.valid) {
+        hasSpeed = false;
+        return;
+    }
+    const double lat = toCoordinate(rmc.latitude);
+    const double lon = toCoordinate(rmc.longitude);
+    if (!std::isnan(lat) && !std::isnan(lon)) {
+        hasPosition = true;
+        latitude = lat;
+        longitude = lon;
+    }
+    const float knots = toFloatOrNan(rmc.speed);
+    if (std::isnan(knots)) {
+        hasSpeed = false;
+        return;
+    }
+    hasSpeed = true;
+    speedMps = knots * METERS_PER_SECOND_PER_KNOT;
+    courseDegrees = toFloatOrNan(rmc.course);
+    if (speedMps > maxSpeedMps) {
+        maxSpeedMps = speedMps;
+    }
+    speedSum += speedMps;
+    speedSamples++;
+}
+
+void GnssModel::onGga(const minmea_sentence_gga& gga, uint32_t nowMs) {
+    ggaFix = gga.fix_quality > 0;
+    ggaSatellites = gga.satellites_tracked;
+    ggaAtMs = stamp(nowMs);
+    ggaHdop = ggaFix ? toFloatOrNan(gga.hdop) : NAN;
+    if (!ggaFix) {
+        hasAltitude = false;
+        return;
+    }
+    const double lat = toCoordinate(gga.latitude);
+    const double lon = toCoordinate(gga.longitude);
+    if (!std::isnan(lat) && !std::isnan(lon)) {
+        hasPosition = true;
+        latitude = lat;
+        longitude = lon;
+    }
+    const float altitude = toFloatOrNan(gga.altitude);
+    hasAltitude = !std::isnan(altitude) && (gga.altitude_units == 'M' || gga.altitude_units == '\0');
+    if (hasAltitude) {
+        altitudeMeters = altitude;
+    }
+}
+
+void GnssModel::onGsa(const minmea_sentence_gsa& gsa, uint32_t nowMs) {
+    gsaAtMs = stamp(nowMs);
+    gsaFix = gsa.fix_type == MINMEA_GPGSA_FIX_3D ? FixType::Fix3d
+        : gsa.fix_type == MINMEA_GPGSA_FIX_2D ? FixType::Fix2d
+        : FixType::None;
+    pdop = toFloatOrNan(gsa.pdop);
+    gsaHdop = toFloatOrNan(gsa.hdop);
+    vdop = toFloatOrNan(gsa.vdop);
+}
+
+FixType GnssModel::currentFix(uint32_t nowMs) const {
+    const bool gsaFresh = fresh(nowMs, gsaAtMs);
+    const bool ggaFresh = fresh(nowMs, ggaAtMs);
+    if (ggaFresh && !ggaFix) {
+        return FixType::None;
+    }
+    if (gsaFresh) {
+        return gsaFix;
+    }
+    return ggaFresh ? FixType::Fix3d : FixType::None;
+}
+
+// TTFF uses the same fix as the screens, plus a valid RMC for the position
+void GnssModel::updateFixState(uint32_t nowMs) {
+    if (hasTtff) {
+        return;
+    }
+    if (currentFix(nowMs) != FixType::None && rmcValid && fresh(nowMs, rmcAtMs)) {
+        hasTtff = true;
+        ttffMs = nowMs - startMs;
+    }
+}
+
+void GnssModel::resetSpeedStats() {
+    maxSpeedMps = hasSpeed ? speedMps : 0;
+    speedSum = 0;
+    speedSamples = 0;
+}
+
+void GnssModel::snapshot(GnssSnapshot& out, uint32_t nowMs) {
+    satellites.expire(nowMs);
+
+    const bool gsaFresh = fresh(nowMs, gsaAtMs);
+    const bool ggaFresh = fresh(nowMs, ggaAtMs);
+    const bool rmcFresh = fresh(nowMs, rmcAtMs);
+    const FixType fix = currentFix(nowMs);
+
+    out.fix = fix;
+    out.satellitesInView = satellites.count();
+    out.satellitesUsed = satellites.usedCount();
+    if (out.satellitesUsed == 0 && ggaFresh && ggaFix) {
+        out.satellitesUsed = ggaSatellites;
+    }
+    out.pdop = gsaFresh ? pdop : NAN;
+    // GSA gives all three DOP values of one solution, GGA's HDOP stands in without GSA
+    out.hdop = gsaFresh ? gsaHdop : ggaFresh ? ggaHdop : NAN;
+    out.vdop = gsaFresh ? vdop : NAN;
+    out.hasTtff = hasTtff;
+    out.ttffMs = ttffMs;
+    out.listeningMs = nowMs - startMs;
+    out.hasPosition = hasPosition;
+    out.latitude = latitude;
+    out.longitude = longitude;
+    out.hasAltitude = hasAltitude && ggaFresh && fix == FixType::Fix3d;
+    out.altitudeMeters = altitudeMeters;
+    out.hasSpeed = hasSpeed && rmcFresh && fix != FixType::None;
+    out.speedMps = speedMps;
+    out.maxSpeedMps = maxSpeedMps;
+    out.averageSpeedMps = speedSamples == 0 ? 0.0f : static_cast<float>(speedSum / speedSamples);
+    out.courseDegrees = (out.hasSpeed && speedMps >= COURSE_MIN_SPEED_MPS) ? courseDegrees : NAN;
+    out.utc = utcTime;
+    out.satelliteCount = satellites.count();
+    for (int i = 0; i < out.satelliteCount; i++) {
+        out.satellites[i] = satellites.at(i);
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssModel.h b/Apps/GpsViewer/main/Source/core/GnssModel.h
new file mode 100644
index 0000000..34780a4
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssModel.h
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "GnssTypes.h"
+#include "SatelliteDb.h"
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+enum class FixType : uint8_t {
+    None,
+    Fix2d,
+    Fix3d,
+};
+
+struct UtcDateTime {
+    bool valid;
+    int year;
+    int month;
+    int day;
+    int hour;
+    int minute;
+    int second;
+};
+
+// Everything the screens show, copied out of GnssModel in one go
+struct GnssSnapshot {
+    FixType fix;
+    int satellitesUsed;
+    int satellitesInView;
+    // NAN when unknown
+    float pdop;
+    float hdop;
+    float vdop;
+    bool hasTtff;
+    uint32_t ttffMs;
+    uint32_t listeningMs;
+    bool hasPosition;
+    double latitude;
+    double longitude;
+    bool hasAltitude;
+    float altitudeMeters;
+    bool hasSpeed;
+    float speedMps;
+    float maxSpeedMps;
+    float averageSpeedMps;
+    // NAN while slower than COURSE_MIN_SPEED_MPS
+    float courseDegrees;
+    UtcDateTime utc;
+    int satelliteCount;
+    Satellite satellites[SatelliteDb::MAX_SATELLITES];
+};
+
+constexpr float COURSE_MIN_SPEED_MPS = 1.0f;
+constexpr float METERS_PER_SECOND_PER_KNOT = 0.514444f;
+
+class GnssModel {
+public:
+    void reset(uint32_t nowMs);
+    void onEvent(const GnssEvent& event, uint32_t nowMs);
+    void resetSpeedStats();
+    void snapshot(GnssSnapshot& out, uint32_t nowMs);
+    int satellitesInView() const { return satellites.count(); }
+    const UtcDateTime& utc() const { return utcTime; }
+
+private:
+    void onRmc(const minmea_sentence_rmc& rmc, uint32_t nowMs);
+    void onGga(const minmea_sentence_gga& gga, uint32_t nowMs);
+    void onGsa(const minmea_sentence_gsa& gsa, uint32_t nowMs);
+    // The fix shown at nowMs: a fresh GSA decides, a fresh GGA without a fix overrides it
+    FixType currentFix(uint32_t nowMs) const;
+    void updateFixState(uint32_t nowMs);
+
+    SatelliteDb satellites;
+    uint32_t startMs = 0;
+    FixType gsaFix = FixType::None;
+    uint32_t gsaAtMs = 0;
+    bool ggaFix = false;
+    int ggaSatellites = 0;
+    uint32_t ggaAtMs = 0;
+    bool rmcValid = false;
+    uint32_t rmcAtMs = 0;
+    float pdop = 0;
+    float gsaHdop = 0;
+    float ggaHdop = 0;
+    float vdop = 0;
+    bool hasTtff = false;
+    uint32_t ttffMs = 0;
+    bool hasPosition = false;
+    double latitude = 0;
+    double longitude = 0;
+    // Altitude comes from GGA, speed and course from RMC. Each expires with its sentence.
+    bool hasAltitude = false;
+    float altitudeMeters = 0;
+    bool hasSpeed = false;
+    float speedMps = 0;
+    float courseDegrees = 0;
+    float maxSpeedMps = 0;
+    double speedSum = 0;
+    uint32_t speedSamples = 0;
+    UtcDateTime utcTime {};
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssTypes.cpp b/Apps/GpsViewer/main/Source/core/GnssTypes.cpp
new file mode 100644
index 0000000..547483f
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssTypes.cpp
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "GnssTypes.h"
+
+namespace gpsviewer {
+
+GnssSystem systemFromTalker(const char* talker) {
+    if (talker == nullptr || talker[0] == '\0') {
+        return GnssSystem::Unknown;
+    }
+    // No tables of string pointers: the app loader leaves pointers in data tables unrelocated
+    const char first = talker[0];
+    const char second = talker[1];
+    if (first == 'G') {
+        switch (second) {
+            case 'P': return GnssSystem::Gps;
+            case 'L': return GnssSystem::Glonass;
+            case 'A': return GnssSystem::Galileo;
+            case 'B': return GnssSystem::Beidou;
+            case 'Q': return GnssSystem::Qzss;
+            case 'I': return GnssSystem::Navic;
+            default: return GnssSystem::Unknown;
+        }
+    }
+    if (first == 'B' && second == 'D') return GnssSystem::Beidou;
+    if (first == 'Q' && second == 'Z') return GnssSystem::Qzss;
+    return GnssSystem::Unknown;
+}
+
+GnssSystem systemFromId(int id) {
+    if (id >= 1 && id <= 32) return GnssSystem::Gps;
+    if ((id >= 33 && id <= 64) || (id >= 120 && id <= 158)) return GnssSystem::Sbas;
+    if (id >= 65 && id <= 96) return GnssSystem::Glonass;
+    if (id >= 193 && id <= 202) return GnssSystem::Qzss;
+    return GnssSystem::Unknown;
+}
+
+GnssSystem systemOfSatellite(const char* talker, int id) {
+    const GnssSystem fromTalker = systemFromTalker(talker);
+    if (fromTalker == GnssSystem::Unknown) {
+        return systemFromId(id);
+    }
+    if (fromTalker == GnssSystem::Gps) {
+        const GnssSystem fromId = systemFromId(id);
+        if (fromId == GnssSystem::Sbas || fromId == GnssSystem::Qzss) {
+            return fromId;
+        }
+    }
+    return fromTalker;
+}
+
+char systemLetter(GnssSystem system) {
+    switch (system) {
+        case GnssSystem::Gps: return 'G';
+        case GnssSystem::Glonass: return 'R';
+        case GnssSystem::Galileo: return 'E';
+        case GnssSystem::Beidou: return 'C';
+        case GnssSystem::Qzss: return 'J';
+        case GnssSystem::Sbas: return 'S';
+        case GnssSystem::Navic: return 'I';
+        default: return '?';
+    }
+}
+
+const char* systemName(GnssSystem system) {
+    switch (system) {
+        case GnssSystem::Gps: return "GPS";
+        case GnssSystem::Glonass: return "GLONASS";
+        case GnssSystem::Galileo: return "Galileo";
+        case GnssSystem::Beidou: return "BeiDou";
+        case GnssSystem::Qzss: return "QZSS";
+        case GnssSystem::Sbas: return "SBAS";
+        case GnssSystem::Navic: return "NavIC";
+        default: return "Unknown";
+    }
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/GnssTypes.h b/Apps/GpsViewer/main/Source/core/GnssTypes.h
new file mode 100644
index 0000000..13c7d05
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/GnssTypes.h
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include <minmea.h>
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+enum class GnssSystem : uint8_t {
+    Unknown,
+    Gps,
+    Glonass,
+    Galileo,
+    Beidou,
+    Qzss,
+    Sbas,
+    Navic,
+};
+
+constexpr int GNSS_SYSTEM_COUNT = 8;
+
+enum class GnssEventType : uint8_t {
+    Rmc,
+    Gga,
+    Gsv,
+    Gsa,
+};
+
+// The data of one parsed NMEA sentence, filled from a GpsEvent
+struct GnssEvent {
+    GnssEventType type;
+    char talker[3];
+    union {
+        minmea_sentence_rmc rmc;
+        minmea_sentence_gga gga;
+        minmea_sentence_gsv gsv;
+        minmea_sentence_gsa gsa;
+    } data;
+};
+
+// "GP" Gps, "GL" Glonass, "GA" Galileo, "GB" and "BD" Beidou, "GQ" and "QZ" Qzss, "GI" Navic.
+// "GN", empty and anything else give Unknown: the satellite ID decides then.
+GnssSystem systemFromTalker(const char* talker);
+
+// NMEA ID ranges: 1..32 GPS, 33..64 and 120..158 SBAS, 65..96 GLONASS, 193..202 QZSS. Others give Unknown.
+GnssSystem systemFromId(int id);
+
+// System of a satellite listed under a talker. A GP talker also carries SBAS and QZSS IDs.
+GnssSystem systemOfSatellite(const char* talker, int id);
+
+// G GPS, R GLONASS, E Galileo, C BeiDou, J QZSS, S SBAS, I NavIC, ? unknown
+char systemLetter(GnssSystem system);
+
+const char* systemName(GnssSystem system);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/NmeaWriter.cpp b/Apps/GpsViewer/main/Source/core/NmeaWriter.cpp
new file mode 100644
index 0000000..d5ac7c2
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/NmeaWriter.cpp
@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "NmeaWriter.h"
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+struct Out {
+    char* buf;
+    size_t cap;
+    size_t len;
+    bool ok;
+};
+
+void put(Out& o, const char* fmt, ...) {
+    if (!o.ok) {
+        return;
+    }
+    va_list ap;
+    va_start(ap, fmt);
+    int n = vsnprintf(o.buf + o.len, o.cap - o.len, fmt, ap);
+    va_end(ap);
+    if (n < 0 || static_cast<size_t>(n) >= o.cap - o.len) {
+        o.ok = false;
+        return;
+    }
+    o.len += static_cast<size_t>(n);
+}
+
+// Writes value/scale with log10(scale) decimals, nothing for scale 0 (empty field).
+// withSign false writes the absolute value because the hemisphere letter carries the sign.
+void putFloat(Out& o, const minmea_float& f, int intDigits, bool withSign) {
+    if (f.scale <= 0) {
+        return;
+    }
+    int64_t v = f.value;
+    const bool negative = v < 0;
+    if (negative) {
+        v = -v;
+    }
+    int decimals = 0;
+    int64_t div = 1;
+    for (int64_t s = f.scale; s > 1; s /= 10) {
+        decimals++;
+        div *= 10;
+    }
+    if (negative && withSign) {
+        put(o, "-");
+    }
+    const long long ip = static_cast<long long>(v / div);
+    if (decimals > 0) {
+        put(o, "%0*lld.%0*lld", intDigits, ip, decimals, static_cast<long long>(v % div));
+    } else {
+        put(o, "%0*lld", intDigits, ip);
+    }
+}
+
+void putCoord(Out& o, const minmea_float& f, int intDigits, char positive, char negative) {
+    put(o, ",");
+    putFloat(o, f, intDigits, false);
+    put(o, ",");
+    if (f.scale > 0) {
+        put(o, "%c", f.value < 0 ? negative : positive);
+    }
+}
+
+void putTime(Out& o, const minmea_time& t) {
+    put(o, ",");
+    if (t.hours < 0) {
+        return;
+    }
+    put(o, "%02d%02d%02d", t.hours, t.minutes, t.seconds);
+    int us = t.microseconds < 0 ? 0 : t.microseconds;
+    int digits = 6;
+    while (digits > 2 && us % 10 == 0) {
+        us /= 10;
+        digits--;
+    }
+    put(o, ".%0*d", digits, us);
+}
+
+void putDate(Out& o, const minmea_date& d) {
+    put(o, ",");
+    if (d.day < 0) {
+        return;
+    }
+    put(o, "%02d%02d%02d", d.day, d.month, d.year);
+}
+
+void putChar(Out& o, char c) {
+    put(o, ",");
+    if (c != 0) {
+        put(o, "%c", c);
+    }
+}
+
+void putFloatField(Out& o, const minmea_float& f) {
+    put(o, ",");
+    putFloat(o, f, 1, true);
+}
+
+void putRmc(Out& o, const minmea_sentence_rmc& r) {
+    putTime(o, r.time);
+    put(o, r.valid ? ",A" : ",V");
+    putCoord(o, r.latitude, 4, 'N', 'S');
+    putCoord(o, r.longitude, 5, 'E', 'W');
+    putFloatField(o, r.speed);
+    putFloatField(o, r.course);
+    putDate(o, r.date);
+    putCoord(o, r.variation, 1, 'E', 'W');
+}
+
+void putGga(Out& o, const minmea_sentence_gga& g) {
+    putTime(o, g.time);
+    putCoord(o, g.latitude, 4, 'N', 'S');
+    putCoord(o, g.longitude, 5, 'E', 'W');
+    put(o, ",%d,%02d", g.fix_quality, g.satellites_tracked);
+    putFloatField(o, g.hdop);
+    putFloatField(o, g.altitude);
+    putChar(o, g.altitude_units);
+    putFloatField(o, g.height);
+    putChar(o, g.height_units);
+    putFloatField(o, g.dgps_age);
+    put(o, ",");
+}
+
+void putGsa(Out& o, const minmea_sentence_gsa& a) {
+    putChar(o, a.mode);
+    put(o, ",%d", a.fix_type);
+    for (int i = 0; i < 12; i++) {
+        put(o, ",");
+        if (a.sats[i] != 0) {
+            put(o, "%02d", a.sats[i]);
+        }
+    }
+    putFloatField(o, a.pdop);
+    putFloatField(o, a.hdop);
+    putFloatField(o, a.vdop);
+}
+
+void putGsv(Out& o, const minmea_sentence_gsv& v) {
+    put(o, ",%d,%d,%d", v.total_msgs, v.msg_nr, v.total_sats);
+    int last = -1;
+    for (int i = 0; i < 4; i++) {
+        const minmea_sat_info& s = v.sats[i];
+        if (s.nr != 0 || s.elevation != 0 || s.azimuth != 0 || s.snr != 0) {
+            last = i;
+        }
+    }
+    for (int i = 0; i <= last; i++) {
+        const minmea_sat_info& s = v.sats[i];
+        put(o, ",");
+        if (s.nr != 0) {
+            put(o, "%02d", s.nr);
+        }
+        put(o, ",%02d,%03d,%02d", s.elevation, s.azimuth, s.snr);
+    }
+}
+
+} // namespace
+
+size_t formatNmeaLine(const GnssEvent& event, char* out, size_t outSize) {
+    if (out == nullptr || outSize == 0) {
+        return 0;
+    }
+    Out o = {out, outSize, 0, true};
+    const bool hasTalker = event.talker[0] != '\0' && event.talker[1] != '\0';
+    const char t0 = hasTalker ? event.talker[0] : 'G';
+    const char t1 = hasTalker ? event.talker[1] : 'N';
+    const char* name = "RMC";
+    switch (event.type) {
+        case GnssEventType::Rmc: name = "RMC"; break;
+        case GnssEventType::Gga: name = "GGA"; break;
+        case GnssEventType::Gsv: name = "GSV"; break;
+        case GnssEventType::Gsa: name = "GSA"; break;
+    }
+    put(o, "$%c%c%s", t0, t1, name);
+    switch (event.type) {
+        case GnssEventType::Rmc: putRmc(o, event.data.rmc); break;
+        case GnssEventType::Gga: putGga(o, event.data.gga); break;
+        case GnssEventType::Gsv: putGsv(o, event.data.gsv); break;
+        case GnssEventType::Gsa: putGsa(o, event.data.gsa); break;
+    }
+    if (!o.ok) {
+        out[0] = '\0';
+        return 0;
+    }
+    unsigned checksum = 0;
+    for (size_t i = 1; i < o.len; i++) {
+        checksum ^= static_cast<unsigned char>(out[i]);
+    }
+    put(o, "*%02X\r\n", checksum);
+    if (!o.ok) {
+        out[0] = '\0';
+        return 0;
+    }
+    return o.len;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/NmeaWriter.h b/Apps/GpsViewer/main/Source/core/NmeaWriter.h
new file mode 100644
index 0000000..c77470a
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/NmeaWriter.h
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "GnssTypes.h"
+
+#include <cstddef>
+
+namespace gpsviewer {
+
+// Formats an event back into one NMEA 0183 line, "$<talker><type>,...*XX\r\n", so that
+// parseNmeaLine() gives the same event again. An empty talker is written as "GN".
+// Returns the length written without the NUL, or 0 when it doesn't fit in out.
+size_t formatNmeaLine(const GnssEvent& event, char* out, size_t outSize);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp b/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
new file mode 100644
index 0000000..59d1f07
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SatelliteDb.cpp
@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "SatelliteDb.h"
+
+#include <cstring>
+
+namespace gpsviewer {
+
+namespace {
+
+// GSV sets of the same talker within this time of the epoch's first set belong to that epoch.
+// Receivers send one set per signal band (L1, L5) right after each other, so the sets are merged.
+// The window is counted from the first set, so a receiver sending faster than this still starts new epochs.
+constexpr uint32_t SAME_EPOCH_MS = 500;
+// Combined (GN) GSA sentences closer together than this belong to one epoch
+constexpr uint32_t GSA_EPOCH_MS = 300;
+
+bool olderThan(uint32_t nowMs, uint32_t thenMs, uint32_t ageMs) {
+    return static_cast<uint32_t>(nowMs - thenMs) > ageMs;
+}
+
+uint32_t systemBit(GnssSystem system) {
+    return 1U << static_cast<uint32_t>(system);
+}
+
+// Maps an ID from a GSA sentence to its satellite system, once the sentence's system is known
+GnssSystem usedIdSystem(GnssSystem gsaSystem, int id) {
+    if (gsaSystem == GnssSystem::Gps) {
+        return systemOfSatellite("GP", id);
+    }
+    if (gsaSystem == GnssSystem::Unknown) {
+        return systemFromId(id);
+    }
+    return gsaSystem;
+}
+
+} // namespace
+
+void SatelliteDb::clear() {
+    satelliteCount = 0;
+    groupCount = 0;
+    combinedGsaAtMs = 0;
+    combinedGsaSystems = 0;
+}
+
+int SatelliteDb::groupIndex(const char* talker) {
+    for (int i = 0; i < groupCount; i++) {
+        if (strncmp(groups[i].talker, talker, 2) == 0) {
+            return i;
+        }
+    }
+    if (groupCount == MAX_GROUPS) {
+        return -1;
+    }
+    PendingSet& set = groups[groupCount];
+    set = {};
+    strncpy(set.talker, talker, 2);
+    set.talker[2] = '\0';
+    return groupCount++;
+}
+
+int SatelliteDb::find(GnssSystem system, int id) const {
+    for (int i = 0; i < satelliteCount; i++) {
+        if (satellites[i].system == system && satellites[i].id == id) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+void SatelliteDb::onGsv(const char* talker, const minmea_sentence_gsv& gsv, uint32_t nowMs) {
+    const int group = groupIndex(talker);
+    if (group < 0) {
+        return;
+    }
+    PendingSet& set = groups[group];
+    if (gsv.msg_nr == 1) {
+        set.count = 0;
+        set.totalMessages = gsv.total_msgs;
+        set.nextMessage = 1;
+    }
+    if (gsv.msg_nr != set.nextMessage || gsv.total_msgs != set.totalMessages || gsv.total_msgs < 1) {
+        set.nextMessage = 0;
+        return;
+    }
+    // NMEA 4.10 adds a signal ID after the satellites, which minmea reads as the next satellite's
+    // number in a last message with fewer than four satellites. Entries beyond total_sats are dropped.
+    for (int i = 0; i < 4; i++) {
+        const minmea_sat_info& info = gsv.sats[i];
+        const int position = (gsv.msg_nr - 1) * 4 + i;
+        if (info.nr <= 0 || set.count == MAX_SATELLITES || (gsv.total_sats > 0 && position >= gsv.total_sats)) {
+            continue;
+        }
+        Satellite& satellite = set.satellites[set.count++];
+        satellite = {};
+        satellite.system = systemOfSatellite(talker, info.nr);
+        satellite.group = static_cast<uint8_t>(group);
+        satellite.id = static_cast<int16_t>(info.nr);
+        // minmea gives 0 for empty fields, and receivers leave both empty for satellites without a position
+        const bool hasPosition = info.elevation != 0 || info.azimuth != 0;
+        satellite.elevation = static_cast<int16_t>(hasPosition ? info.elevation : -1);
+        satellite.azimuth = static_cast<int16_t>(hasPosition ? info.azimuth : -1);
+        satellite.snr = static_cast<int16_t>(info.snr > 0 ? info.snr : 0);
+        satellite.lastSeenMs = nowMs;
+    }
+    if (gsv.msg_nr == gsv.total_msgs) {
+        commit(group, nowMs);
+        set.nextMessage = 0;
+    } else {
+        set.nextMessage++;
+    }
+}
+
+void SatelliteDb::commit(int group, uint32_t nowMs) {
+    PendingSet& set = groups[group];
+    const bool merge = set.committed && !olderThan(nowMs, set.epochStartMs, SAME_EPOCH_MS);
+
+    if (!merge) {
+        int kept = 0;
+        for (int i = 0; i < satelliteCount; i++) {
+            if (satellites[i].group != group) {
+                satellites[kept++] = satellites[i];
+                continue;
+            }
+            // Keep the used flag of satellites that are in the new set
+            for (int j = 0; j < set.count; j++) {
+                Satellite& fresh = set.satellites[j];
+                if (fresh.system == satellites[i].system && fresh.id == satellites[i].id) {
+                    fresh.used = satellites[i].used;
+                    fresh.usedBy = satellites[i].usedBy;
+                    fresh.usedAtMs = satellites[i].usedAtMs;
+                }
+            }
+        }
+        satelliteCount = kept;
+    }
+
+    for (int j = 0; j < set.count; j++) {
+        const Satellite& fresh = set.satellites[j];
+        const int index = find(fresh.system, fresh.id);
+        if (index < 0) {
+            if (satelliteCount < MAX_SATELLITES) {
+                satellites[satelliteCount++] = fresh;
+            }
+            continue;
+        }
+        Satellite& existing = satellites[index];
+        if (!merge || fresh.snr > existing.snr) {
+            existing.snr = fresh.snr;
+        }
+        if (fresh.elevation >= 0) {
+            existing.elevation = fresh.elevation;
+            existing.azimuth = fresh.azimuth;
+        }
+        existing.lastSeenMs = nowMs;
+    }
+
+    if (!merge) {
+        set.epochStartMs = nowMs;
+    }
+    set.committed = true;
+}
+
+// Combined GSA sentences don't say their system in minmea's fields. Receivers send one per system
+// per epoch, so each system is picked once per epoch: the one whose satellites in view contain
+// most of the used IDs. Ties go to the first system in enum order. Without a match the ID ranges decide.
+GnssSystem SatelliteDb::guessGsaSystem(const int* ids, int idCount) const {
+    GnssSystem best = GnssSystem::Unknown;
+    int bestScore = 0;
+    for (int s = 1; s < GNSS_SYSTEM_COUNT; s++) {
+        const auto system = static_cast<GnssSystem>(s);
+        if (system == GnssSystem::Sbas || (combinedGsaSystems & systemBit(system)) != 0) {
+            continue;
+        }
+        int score = 0;
+        for (int i = 0; i < idCount; i++) {
+            if (find(usedIdSystem(system, ids[i]), ids[i]) >= 0) {
+                score++;
+            }
+        }
+        if (score > bestScore) {
+            best = system;
+            bestScore = score;
+        }
+    }
+    return best;
+}
+
+// A GSA sentence replaces the used flags it set last time, so a GP sentence also clears the
+// SBAS and QZSS satellites it listed before, and leaves those of a QZ or GN sentence alone
+void SatelliteDb::markUsed(GnssSystem gsaSystem, const int* ids, int idCount, uint32_t nowMs) {
+    if (gsaSystem != GnssSystem::Unknown) {
+        for (int i = 0; i < satelliteCount; i++) {
+            if (satellites[i].used && satellites[i].usedBy == gsaSystem) {
+                satellites[i].used = false;
+            }
+        }
+    }
+    for (int i = 0; i < idCount; i++) {
+        const int index = find(usedIdSystem(gsaSystem, ids[i]), ids[i]);
+        if (index >= 0) {
+            satellites[index].used = true;
+            satellites[index].usedBy = gsaSystem;
+            satellites[index].usedAtMs = nowMs;
+        }
+    }
+}
+
+void SatelliteDb::clearUsed() {
+    for (int i = 0; i < satelliteCount; i++) {
+        satellites[i].used = false;
+    }
+}
+
+// Used IDs belong to the talker's system when the talker names one. A GP talker can also list
+// SBAS (33..64, 120..158) and QZSS (193..202) IDs. Combined talkers are resolved by guessGsaSystem().
+void SatelliteDb::onGsa(const char* talker, const minmea_sentence_gsa& gsa, uint32_t nowMs) {
+    int ids[12];
+    int idCount = 0;
+    for (int id : gsa.sats) {
+        if (id > 0) {
+            ids[idCount++] = id;
+        }
+    }
+
+    GnssSystem system = systemFromTalker(talker);
+    if (system == GnssSystem::Unknown) {
+        if (idCount == 0) {
+            // An empty combined sentence without a fix: no satellite is used. With a fix it's
+            // only a system without used satellites, and its system can't be told.
+            if (gsa.fix_type != MINMEA_GPGSA_FIX_2D && gsa.fix_type != MINMEA_GPGSA_FIX_3D) {
+                clearUsed();
+            }
+            return;
+        }
+        if (combinedGsaAtMs == 0 || olderThan(nowMs, combinedGsaAtMs, GSA_EPOCH_MS)) {
+            combinedGsaSystems = 0;
+        }
+        combinedGsaAtMs = nowMs;
+        system = guessGsaSystem(ids, idCount);
+        if (system != GnssSystem::Unknown) {
+            combinedGsaSystems |= systemBit(system);
+        }
+    }
+    markUsed(system, ids, idCount, nowMs);
+}
+
+void SatelliteDb::expire(uint32_t nowMs) {
+    int kept = 0;
+    for (int i = 0; i < satelliteCount; i++) {
+        Satellite& satellite = satellites[i];
+        if (olderThan(nowMs, satellite.lastSeenMs, EXPIRY_MS)) {
+            continue;
+        }
+        if (satellite.used && olderThan(nowMs, satellite.usedAtMs, USED_EXPIRY_MS)) {
+            satellite.used = false;
+        }
+        satellites[kept++] = satellite;
+    }
+    satelliteCount = kept;
+}
+
+int SatelliteDb::usedCount() const {
+    int used = 0;
+    for (int i = 0; i < satelliteCount; i++) {
+        if (satellites[i].used) {
+            used++;
+        }
+    }
+    return used;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SatelliteDb.h b/Apps/GpsViewer/main/Source/core/SatelliteDb.h
new file mode 100644
index 0000000..4bf1867
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SatelliteDb.h
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "GnssTypes.h"
+
+#include <cstdint>
+
+namespace gpsviewer {
+
+struct Satellite {
+    GnssSystem system;
+    // Index of the GSV talker group that reported it, see SatelliteDb
+    uint8_t group;
+    int16_t id;
+    // Degrees, -1 when the receiver gave no position
+    int16_t elevation;
+    int16_t azimuth;
+    // dB-Hz, 0 when not tracked
+    int16_t snr;
+    bool used;
+    // The GSA sentence that marked it used: its talker's system, or the system picked for a combined talker
+    GnssSystem usedBy;
+    uint32_t lastSeenMs;
+    uint32_t usedAtMs;
+};
+
+// Satellites in view, assembled from GSV sets and marked used from GSA sentences
+class SatelliteDb {
+public:
+    static constexpr int MAX_SATELLITES = 72;
+    static constexpr int MAX_GROUPS = 8;
+    static constexpr uint32_t EXPIRY_MS = 10000;
+    static constexpr uint32_t USED_EXPIRY_MS = 3000;
+
+    void clear();
+    void onGsv(const char* talker, const minmea_sentence_gsv& gsv, uint32_t nowMs);
+    void onGsa(const char* talker, const minmea_sentence_gsa& gsa, uint32_t nowMs);
+    // Drops satellites not seen for EXPIRY_MS and used flags older than USED_EXPIRY_MS
+    void expire(uint32_t nowMs);
+
+    int count() const { return satelliteCount; }
+    const Satellite& at(int index) const { return satellites[index]; }
+    int usedCount() const;
+
+private:
+    struct PendingSet {
+        char talker[3];
+        int totalMessages;
+        int nextMessage;
+        int count;
+        Satellite satellites[MAX_SATELLITES];
+        // First commit of the current epoch. Later sets within SAME_EPOCH_MS of it are merged into it.
+        uint32_t epochStartMs;
+        bool committed;
+    };
+
+    int groupIndex(const char* talker);
+    void commit(int group, uint32_t nowMs);
+    int find(GnssSystem system, int id) const;
+    void markUsed(GnssSystem system, const int* ids, int idCount, uint32_t nowMs);
+    void clearUsed();
+    GnssSystem guessGsaSystem(const int* ids, int idCount) const;
+
+    Satellite satellites[MAX_SATELLITES] {};
+    int satelliteCount = 0;
+    PendingSet groups[MAX_GROUPS] {};
+    int groupCount = 0;
+    uint32_t combinedGsaAtMs = 0;
+    uint32_t combinedGsaSystems = 0;
+};
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Settings.cpp b/Apps/GpsViewer/main/Source/core/Settings.cpp
new file mode 100644
index 0000000..d7157de
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Settings.cpp
@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "Settings.h"
+
+#include <cstdio>
+
+namespace gpsviewer {
+
+namespace {
+
+bool isBlank(char c) {
+    return c == ' ' || c == '\t' || c == '\r';
+}
+
+// True when the range [begin, end) equals the NUL-terminated word
+bool sameText(const char* begin, const char* end, const char* word) {
+    const char* p = begin;
+    while (p < end && *word != '\0') {
+        if (*p != *word) {
+            return false;
+        }
+        ++p;
+        ++word;
+    }
+    return p == end && *word == '\0';
+}
+
+void applyLine(const char* begin, const char* end, Settings& settings) {
+    while (begin < end && isBlank(*begin)) {
+        ++begin;
+    }
+    while (end > begin && isBlank(end[-1])) {
+        --end;
+    }
+    if (begin == end || *begin == '#') {
+        return;
+    }
+
+    const char* eq = begin;
+    while (eq < end && *eq != '=') {
+        ++eq;
+    }
+    if (eq == end) {
+        return;
+    }
+
+    const char* keyEnd = eq;
+    while (keyEnd > begin && isBlank(keyEnd[-1])) {
+        --keyEnd;
+    }
+    const char* value = eq + 1;
+    while (value < end && isBlank(*value)) {
+        ++value;
+    }
+
+    if (sameText(begin, keyEnd, "units")) {
+        if (sameText(value, end, "metric")) {
+            settings.units = Units::Metric;
+        } else if (sameText(value, end, "imperial")) {
+            settings.units = Units::Imperial;
+        } else if (sameText(value, end, "nautical")) {
+            settings.units = Units::Nautical;
+        }
+    } else if (sameText(begin, keyEnd, "coordinates")) {
+        if (sameText(value, end, "dd")) {
+            settings.coordinateFormat = CoordinateFormat::Degrees;
+        } else if (sameText(value, end, "dm")) {
+            settings.coordinateFormat = CoordinateFormat::DegreesMinutes;
+        } else if (sameText(value, end, "dms")) {
+            settings.coordinateFormat = CoordinateFormat::DegreesMinutesSeconds;
+        }
+    } else if (sameText(begin, keyEnd, "night")) {
+        if (sameText(value, end, "0")) {
+            settings.nightMode = false;
+        } else if (sameText(value, end, "1")) {
+            settings.nightMode = true;
+        }
+    }
+}
+
+const char* unitsName(Units units) {
+    switch (units) {
+        case Units::Imperial:
+            return "imperial";
+        case Units::Nautical:
+            return "nautical";
+        case Units::Metric:
+            break;
+    }
+    return "metric";
+}
+
+const char* coordinatesName(CoordinateFormat format) {
+    switch (format) {
+        case CoordinateFormat::DegreesMinutes:
+            return "dm";
+        case CoordinateFormat::DegreesMinutesSeconds:
+            return "dms";
+        case CoordinateFormat::Degrees:
+            break;
+    }
+    return "dd";
+}
+
+} // namespace
+
+Settings parseSettings(const char* text) {
+    Settings settings;
+    if (!text) {
+        return settings;
+    }
+    const char* line = text;
+    while (*line != '\0') {
+        const char* end = line;
+        while (*end != '\0' && *end != '\n') {
+            ++end;
+        }
+        applyLine(line, end, settings);
+        line = (*end == '\n') ? end + 1 : end;
+    }
+    return settings;
+}
+
+size_t serializeSettings(const Settings& settings, char* out, size_t outSize) {
+    if (!out || outSize == 0) {
+        return 0;
+    }
+    const int written = std::snprintf(out, outSize,
+                                      "units=%s\ncoordinates=%s\nnight=%d\n",
+                                      unitsName(settings.units),
+                                      coordinatesName(settings.coordinateFormat),
+                                      settings.nightMode ? 1 : 0);
+    // A text that does not fit is not written at all, so a partial file never parses to odd values
+    if (written < 0 || static_cast<size_t>(written) >= outSize) {
+        out[0] = '\0';
+        return 0;
+    }
+    return static_cast<size_t>(written);
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/Settings.h b/Apps/GpsViewer/main/Source/core/Settings.h
new file mode 100644
index 0000000..d9fbab1
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/Settings.h
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+#include "Format.h"
+
+#include <cstddef>
+
+namespace gpsviewer {
+
+struct Settings {
+    Units units = Units::Metric;
+    CoordinateFormat coordinateFormat = CoordinateFormat::Degrees;
+    bool nightMode = false;
+};
+
+// Text format, one "key=value" per line: units=metric|imperial|nautical, coordinates=dd|dm|dms,
+// night=0|1. Unknown keys and bad values are ignored and keep the defaults.
+Settings parseSettings(const char* text);
+// Returns the number of characters written, without the NUL
+size_t serializeSettings(const Settings& settings, char* out, size_t outSize);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SunTimes.cpp b/Apps/GpsViewer/main/Source/core/SunTimes.cpp
new file mode 100644
index 0000000..555b742
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SunTimes.cpp
@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#include "SunTimes.h"
+
+#include <cmath>
+
+namespace gpsviewer {
+
+namespace {
+
+constexpr double PI_VALUE = 3.14159265358979323846;
+constexpr double DEG = PI_VALUE / 180.0;
+
+struct SolarValues {
+    double declination; // radians
+    double equationOfTime; // minutes
+};
+
+SolarValues solarAt(double julianDay) {
+    double t = (julianDay - 2451545.0) / 36525.0;
+    double l0 = std::fmod(280.46646 + t * (36000.76983 + t * 0.0003032), 360.0);
+    double m = (357.52911 + t * (35999.05029 - 0.0001537 * t)) * DEG;
+    double e = 0.016708634 - t * (0.000042037 + 0.0000001267 * t);
+    double center = std::sin(m) * (1.914602 - t * (0.004817 + 0.000014 * t))
+        + std::sin(2 * m) * (0.019993 - 0.000101 * t)
+        + std::sin(3 * m) * 0.000289;
+    double trueLong = l0 + center;
+    double omega = (125.04 - 1934.136 * t) * DEG;
+    double apparent = (trueLong - 0.00569 - 0.00478 * std::sin(omega)) * DEG;
+    double seconds = 21.448 - t * (46.815 + t * (0.00059 - t * 0.001813));
+    double meanObliq = 23.0 + (26.0 + seconds / 60.0) / 60.0;
+    double obliq = (meanObliq + 0.00256 * std::cos(omega)) * DEG;
+    double decl = std::asin(std::sin(obliq) * std::sin(apparent));
+    double y = std::tan(obliq / 2.0);
+    y *= y;
+    double l0r = l0 * DEG;
+    double eot = y * std::sin(2 * l0r) - 2 * e * std::sin(m)
+        + 4 * e * y * std::sin(m) * std::cos(2 * l0r)
+        - 0.5 * y * y * std::sin(4 * l0r) - 1.25 * e * e * std::sin(2 * m);
+    return { decl, 4.0 * eot / DEG };
+}
+
+} // namespace
+
+long long utcToEpoch(int year, int month, int day, int hour, int minute, int second) {
+    long long y = year;
+    y -= month <= 2 ? 1 : 0;
+    long long era = (y >= 0 ? y : y - 399) / 400;
+    long long yoe = y - era * 400;
+    long long mp = (month + 9) % 12;
+    long long doy = (153 * mp + 2) / 5 + day - 1;
+    long long doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    long long days = era * 146097 + doe - 719468;
+    return days * 86400 + hour * 3600LL + minute * 60LL + second;
+}
+
+SunTimes computeSunTimes(int year, int month, int day, double latitude, double longitude) {
+    double jdMidnight = (double)utcToEpoch(year, month, day, 0, 0, 0) / 86400.0 + 2440587.5;
+    // Solar noon first guess, then evaluate again at the refined noon
+    SolarValues first = solarAt(jdMidnight + 0.5 - longitude / 360.0);
+    double noon = 720.0 - 4.0 * longitude - first.equationOfTime;
+    SolarValues s = solarAt(jdMidnight + noon / 1440.0);
+
+    double lat = latitude * DEG;
+    double cosHa = std::cos(90.833 * DEG) / (std::cos(lat) * std::cos(s.declination))
+        - std::tan(lat) * std::tan(s.declination);
+
+    SunTimes out { SunDay::Normal, 0.0, 0.0 };
+    if (cosHa > 1.0) {
+        out.day = SunDay::PolarNight;
+        return out;
+    }
+    if (cosHa < -1.0) {
+        out.day = SunDay::PolarDay;
+        return out;
+    }
+    double ha = std::acos(cosHa) / DEG;
+    // Not wrapped into 0..1440, so values may be negative or above 1440
+    out.sunriseUtcMinutes = 720.0 - 4.0 * (longitude + ha) - s.equationOfTime;
+    out.sunsetUtcMinutes = 720.0 - 4.0 * (longitude - ha) - s.equationOfTime;
+    return out;
+}
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/main/Source/core/SunTimes.h b/Apps/GpsViewer/main/Source/core/SunTimes.h
new file mode 100644
index 0000000..25f3917
--- /dev/null
+++ b/Apps/GpsViewer/main/Source/core/SunTimes.h
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+#pragma once
+
+namespace gpsviewer {
+
+enum class SunDay {
+    Normal,
+    PolarDay,
+    PolarNight,
+};
+
+struct SunTimes {
+    SunDay day;
+    // Minutes after 00:00 UTC of the given date, can be below 0 or above 1440
+    double sunriseUtcMinutes;
+    double sunsetUtcMinutes;
+};
+
+// NOAA solar calculator algorithm, with the sun 0.833° below the horizon at rise and set
+SunTimes computeSunTimes(int year, int month, int day, double latitude, double longitude);
+
+// Seconds since 1970-01-01 00:00 UTC
+long long utcToEpoch(int year, int month, int day, int hour, int minute, int second);
+
+} // namespace gpsviewer
diff --git a/Apps/GpsViewer/manifest.properties b/Apps/GpsViewer/manifest.properties
new file mode 100644
index 0000000..d2787d6
--- /dev/null
+++ b/Apps/GpsViewer/manifest.properties
@@ -0,0 +1,11 @@
+manifest.version=0.3
+target.sdk=0.8.0-dev
+target.platforms=esp32,esp32s3,esp32c6,esp32p4
+id=tactility.gpsviewer
+version.name=0.1.0
+version.code=1
+app.0.id=tactility.gpsviewer
+app.0.name=GPS Viewer
+app.0.binary=gpsviewer
+name=GPS Viewer
+description=GNSS receiver status: fix, satellites, signal, sky plot, position and time