Skip to content
Go to file


Failed to load latest commit information.
Latest commit message
Commit time


Build Status Go Report Card Coverage Status GoDoc

This is a NMEA library for the Go programming language (Golang).


  • Parse individual NMEA 0183 sentences
  • Register custom parser for unsupported sentence types
  • User-friendly MIT license


To install go-nmea use go get:

go get

This will then make the package available to you.

Staying up to date

To update go-nmea to the latest version, use go get -u

Supported sentences

At this moment, this library supports the following sentence types:

Sentence type Description
RMC Recommended Minimum Specific GPS/Transit data
PMTK Messages for setting and reading commands for MediaTek gps modules.
GGA GPS Positioning System Fix Data
GSA GPS DOP and active satellites
GSV GPS Satellites in view
GLL Geographic Position, Latitude / Longitude and time
VTG Track Made Good and Ground Speed
ZDA Date & time data
HDT Actual vessel heading in degrees True
GNS Combined GPS fix for GPS, Glonass, Galileo, and BeiDou
PGRME Estimated Position Error (Garmin proprietary sentence)
THS Actual vessel heading in degrees True and status
VDM/VDO Encapsulated binary payload
WPL Waypoint location
RTE Route
VHW Water Speed and Heading
DPT Depth of Water
DBS Depth Below Surface
DBT Depth below transducer

If you need to parse a message that contains an unsupported sentence type you can implement and register your own message parser and get yourself unblocked immediately. Check the example below to know how to implement and register a custom message parser. However, if you think your custom message parser could be beneficial to other users we encourage you to contribute back to the library by submitting a PR and get it included in the list of supported sentences.


Built-in message parsing

package main

import (

func main() {
	sentence := "$GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70"
	s, err := nmea.Parse(sentence)
	if err != nil {
	if s.DataType() == nmea.TypeRMC {
		m := s.(nmea.RMC)
		fmt.Printf("Raw sentence: %v\n", m)
		fmt.Printf("Time: %s\n", m.Time)
		fmt.Printf("Validity: %s\n", m.Validity)
		fmt.Printf("Latitude GPS: %s\n", nmea.FormatGPS(m.Latitude))
		fmt.Printf("Latitude DMS: %s\n", nmea.FormatDMS(m.Latitude))
		fmt.Printf("Longitude GPS: %s\n", nmea.FormatGPS(m.Longitude))
		fmt.Printf("Longitude DMS: %s\n", nmea.FormatDMS(m.Longitude))
		fmt.Printf("Speed: %f\n", m.Speed)
		fmt.Printf("Course: %f\n", m.Course)
		fmt.Printf("Date: %s\n", m.Date)
		fmt.Printf("Variation: %f\n", m.Variation)


$ go run main/main.go

Raw sentence: $GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70
Time: 22:05:16.0000
Validity: A
Latitude GPS: 5133.8200
Latitude DMS: 51° 33' 49.200000"
Longitude GPS: 042.2400
Longitude DMS: 0° 42' 14.400000"
Speed: 173.800000
Course: 231.800000
Date: 13/06/94
Variation: -4.200000

Custom message parsing

If you need to parse a message not supported by the library you can implement your own message parsing. The following example implements a parser for the hypothetical XYZ NMEA sentence type.

package main

import (


// A type to hold the parsed record
type XYZType struct {
	Time    nmea.Time
	Counter int64
	Label   string
	Value   float64

func main() {
	// Do this once it will error if you register the same type multiple times
	err := nmea.RegisterParser("XYZ", func(s nmea.BaseSentence) (nmea.Sentence, error) {
		// This example uses the package builtin parsing helpers
		// you can implement your own parsing logic also
		p := nmea.NewParser(s)
		return XYZType{
			BaseSentence: s,
			Time:         p.Time(0, "time"),
			Label:        p.String(1, "label"),
			Counter:      p.Int64(2, "counter"),
			Value:        p.Float64(3, "value"),
		}, p.Err()

	if err != nil {

	sentence := "$00XYZ,220516,A,23,5133.82,W*42"
	s, err := nmea.Parse(sentence)
	if err != nil {

	m, ok := s.(XYZType)
	if !ok {
		panic("Could not parse type XYZ")

	fmt.Printf("Raw sentence: %v\n", m)
	fmt.Printf("Time: %s\n", m.Time)
	fmt.Printf("Label: %s\n", m.Label)
	fmt.Printf("Counter: %d\n", m.Counter)
	fmt.Printf("Value: %f\n", m.Value)


$ go run main/main.go

Raw sentence: $AAXYZ,220516,A,23,5133.82,W*42
Time: 22:05:16.0000
Label: A
Counter: 23
Value: 5133.820000


Please feel free to submit issues or fork the repository and send pull requests to update the library and fix bugs, implement support for new sentence types, refactor code, etc.



You can’t perform that action at this time.