diff --git a/event/source.go b/event/source.go
index efe3c5d..e9eaad3 100644
--- a/event/source.go
+++ b/event/source.go
@@ -37,7 +37,7 @@
 var globalCallers chan *sources
 
 // RegisterHelper records a function as being an event helper that should not
-// be used when capturing the source infomation on events.
+// be used when capturing the source information on events.
 // v should be either a string or a function pointer.
 // If v is a string it is of the form
 //   Space.Owner.Name
diff --git a/io/spi/devfs.go b/io/spi/devfs.go
index bc421fa..a5f1bca 100644
--- a/io/spi/devfs.go
+++ b/io/spi/devfs.go
@@ -57,11 +57,11 @@
 	// Mode is the SPI mode. SPI mode is a combination of polarity and phases.
 	// CPOL is the high order bit, CPHA is the low order. Pre-computed mode
 	// values are Mode0, Mode1, Mode2 and Mode3. The value of the mode argument
-	// can be overriden by the device's driver.
+	// can be overridden by the device's driver.
 	// Required.
 	Mode Mode
 
-	// MaxSpeed is the max clock speed (Hz) and can be overriden by the device's driver.
+	// MaxSpeed is the max clock speed (Hz) and can be overridden by the device's driver.
 	// Required.
 	MaxSpeed int64
 }
diff --git a/io/spi/devfs_nonlinux.go b/io/spi/devfs_nonlinux.go
index 6b30abc..499d69d 100644
--- a/io/spi/devfs_nonlinux.go
+++ b/io/spi/devfs_nonlinux.go
@@ -24,11 +24,11 @@
 	// Mode is the SPI mode. SPI mode is a combination of polarity and phases.
 	// CPOL is the high order bit, CPHA is the low order. Pre-computed mode
 	// values are Mode0, Mode1, Mode2 and Mode3. The value of the mode argument
-	// can be overriden by the device's driver.
+	// can be overridden by the device's driver.
 	// Required.
 	Mode Mode
 
-	// MaxSpeed is the max clock speed (Hz) and can be overriden by the device's driver.
+	// MaxSpeed is the max clock speed (Hz) and can be overridden by the device's driver.
 	// Required.
 	MaxSpeed int64
 }
diff --git a/io/spi/spi.go b/io/spi/spi.go
index f342cb3..175e20d 100644
--- a/io/spi/spi.go
+++ b/io/spi/spi.go
@@ -27,7 +27,7 @@
 	Mode3 = Mode(3)
 )
 
-// Order is the bit justification to be used while transfering
+// Order is the bit justification to be used while transferring
 // words to the SPI device. MSB-first encoding is more popular
 // than LSB-first.
 type Order int
@@ -50,7 +50,7 @@
 }
 
 // SetMaxSpeed sets the maximum clock speed in Hz.
-// The value can be overriden by SPI device's driver.
+// The value can be overridden by SPI device's driver.
 func (d *Device) SetMaxSpeed(speed int) error {
 	return d.conn.Configure(driver.MaxSpeed, speed)
 }
diff --git a/jsonrpc2/conn.go b/jsonrpc2/conn.go
index b4befbf..39deb67 100644
--- a/jsonrpc2/conn.go
+++ b/jsonrpc2/conn.go
@@ -333,7 +333,7 @@
 	}
 }
 
-// manageQueue reads incoming requests, attempts to proccess them with the preempter, or queue them
+// manageQueue reads incoming requests, attempts to process them with the preempter, or queue them
 // up for normal handling.
 func (c *Connection) manageQueue(ctx context.Context, preempter Preempter, fromRead <-chan *incoming, toDeliver chan<- *incoming) {
 	defer close(toDeliver)
diff --git a/jsonrpc2/net.go b/jsonrpc2/net.go
index c8cfaab..c40c4d8 100644
--- a/jsonrpc2/net.go
+++ b/jsonrpc2/net.go
@@ -21,7 +21,7 @@
 	NetDialer       net.Dialer
 }
 
-// NetListener returns a new Listener that listents on a socket using the net package.
+// NetListener returns a new Listener that listens on a socket using the net package.
 func NetListener(ctx context.Context, network, address string, options NetListenOptions) (Listener, error) {
 	ln, err := options.NetListenConfig.Listen(ctx, network, address)
 	if err != nil {
@@ -83,7 +83,7 @@
 // NetPipe returns a new Listener that listens using net.Pipe.
 // It is only possibly to connect to it using the Dialier returned by the
 // Dialer method, each call to that method will generate a new pipe the other
-// side of which will be returnd from the Accept call.
+// side of which will be returned from the Accept call.
 func NetPipe(ctx context.Context) (Listener, error) {
 	return &netPiper{
 		done:   make(chan struct{}),
diff --git a/jsonrpc2/wire.go b/jsonrpc2/wire.go
index 97b1ae8..4971a92 100644
--- a/jsonrpc2/wire.go
+++ b/jsonrpc2/wire.go
@@ -28,7 +28,7 @@
 	ErrInternal = NewError(-32603, "JSON RPC internal error")
 
 	// The following errors are not part of the json specification, but
-	// compliant extensions specific to this implimentation.
+	// compliant extensions specific to this implementation.
 
 	// ErrServerOverloaded is returned when a message was refused due to a
 	// server being temporarily unable to accept any new messages.
diff --git a/shiny/driver/gldriver/cocoa.go b/shiny/driver/gldriver/cocoa.go
index e13ac80..84bb393 100644
--- a/shiny/driver/gldriver/cocoa.go
+++ b/shiny/driver/gldriver/cocoa.go
@@ -289,7 +289,7 @@
 		// can produce wheel events in opposite directions, but the
 		// direction matches what other programs on the OS do.
 		//
-		// If we wanted to expose the phsyical device motion in the
+		// If we wanted to expose the physical device motion in the
 		// event we could use [NSEvent isDirectionInvertedFromDevice]
 		// to know if "natural scrolling" is enabled.
 		//
diff --git a/shiny/iconvg/buffer.go b/shiny/iconvg/buffer.go
index d5249b5..e1515d0 100644
--- a/shiny/iconvg/buffer.go
+++ b/shiny/iconvg/buffer.go
@@ -12,7 +12,7 @@
 // buffer holds an encoded IconVG graphic.
 //
 // The decodeXxx methods return the decoded value and an integer n, the number
-// of bytes that value was encoded in. They return n == 0 if an error occured.
+// of bytes that value was encoded in. They return n == 0 if an error occurred.
 //
 // The encodeXxx methods append to the buffer, modifying the slice in place.
 type buffer []byte
diff --git a/shiny/internal/xgb/xproto/xproto.go b/shiny/internal/xgb/xproto/xproto.go
index f41e656..5f9a566 100644
--- a/shiny/internal/xgb/xproto/xproto.go
+++ b/shiny/internal/xgb/xproto/xproto.go
@@ -913,7 +913,7 @@
 	xgb.NewEventFuncs[33] = ClientMessageEventNew
 }
 
-// ClientMessageDataUnion is a represention of the ClientMessageDataUnion union type.
+// ClientMessageDataUnion is a representation of the ClientMessageDataUnion union type.
 // Note that to *create* a Union, you should *never* create
 // this struct directly (unless you know what you're doing).
 // Instead use one of the following constructors for 'ClientMessageDataUnion':
diff --git a/sumdb/internal/tlog/tlog.go b/sumdb/internal/tlog/tlog.go
index 6703656..3dd75da 100644
--- a/sumdb/internal/tlog/tlog.go
+++ b/sumdb/internal/tlog/tlog.go
@@ -155,7 +155,7 @@
 		n++
 		indexN = x
 	}
-	// The hash we want was commited with record n,
+	// The hash we want was committed with record n,
 	// meaning it is one of (0, n), (1, n/2), (2, n/4), ...
 	level = int(index - indexN)
 	return level, n >> uint(level)
diff --git a/vulndb/internal/audit/detect.go b/vulndb/internal/audit/detect.go
index cf6fd06..993f84b 100644
--- a/vulndb/internal/audit/detect.go
+++ b/vulndb/internal/audit/detect.go
@@ -260,7 +260,7 @@
 	return packageVulns
 }
 
-// VulnsForSymbol returns vulnerabilites for `symbol` in `mv.VulnsForPackage(importPath)`.
+// VulnsForSymbol returns vulnerabilities for `symbol` in `mv.VulnsForPackage(importPath)`.
 func (mv ModuleVulnerabilities) VulnsForSymbol(importPath, symbol string) []*osv.Entry {
 	vulns := mv.VulnsForPackage(importPath)
 	if vulns == nil {
diff --git a/vulndb/internal/audit/detect_callgraph.go b/vulndb/internal/audit/detect_callgraph.go
index e67381e..983b37a 100644
--- a/vulndb/internal/audit/detect_callgraph.go
+++ b/vulndb/internal/audit/detect_callgraph.go
@@ -26,7 +26,7 @@
 // 'modVulns' vulnerabilities.
 //
 // Returns all findings reachable from pkgs while analyzing each package only once,
-// prefering findings of shorter import traces. For instance, given call chains
+// preferring findings of shorter import traces. For instance, given call chains
 //   A() -> B() -> V
 //   A() -> D() -> B() -> V
 //   D() -> B() -> V
@@ -163,7 +163,7 @@
 		pos = instrPosition(chain.call)
 		if unresolved(chain.call) {
 			// In case of a statically unresolved call site, communicate to the client
-			// that this was approximatelly resolved to chain.f.
+			// that this was approximately resolved to chain.f.
 			desc = fmt.Sprintf("%s(...) [approx. resolved to %s]", callName(chain.call), chain.f)
 		}
 	} else {
diff --git a/vulndb/internal/audit/detect_imports.go b/vulndb/internal/audit/detect_imports.go
index 41f723d..4ceaae2 100644
--- a/vulndb/internal/audit/detect_imports.go
+++ b/vulndb/internal/audit/detect_imports.go
@@ -14,7 +14,7 @@
 // VulnerableImports returns vulnerability findings for packages imported by `pkgs`
 // given the vulnerability and platform info captured in `env`.
 //
-// Returns all findings reachable from `pkgs` while analyzing each package only once, prefering
+// Returns all findings reachable from `pkgs` while analyzing each package only once, preferring
 // findings of shorter import traces. For instance, given import chains
 //   A -> B -> V
 //   A -> D -> B -> V
