Open-source project
fpillet/NSLogger avatar
fpillet/NSLogger

NSLogger: a desktop log viewer for iOS, macOS and Android apps

A modern, flexible logging tool

4,975 stars561 forksObjective-CNOASSERTION

At a glance

What is it?
NSLogger splits logging into a client framework and a macOS viewer that receives traces over Bonjour or the network. It is a good fit for debugging on a device; it is not a production log pipeline.
Who is it for?
Adopt NSLogger if you debug iOS, macOS or Android apps and want device logs, images and binary payloads in a desktop viewer instead of an IDE console. Do not adopt it if you need a server-side log pipeline, long-term retention, or a client for a platform the repository does not cover.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 165 days ago.
What is it written in?
Mainly Objective-C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • fpillet/NSLogger4,975 ★ · -1
Star history
Repository2026-09-232026-11-15
fpillet/NSLogger5k5k

-1 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What NSLogger replaces, and for whom

NSLogger is a logging utility whose client side runs inside macOS, iOS and Android applications and whose viewer is a separate macOS desktop application. The README frames the project as a replacement for console logging, naming NSLog() and Java Log as the traces it supersedes, and saying the viewer replaces the Xcode, Android Studio or Eclipse consoles. That framing matters: this is not a library that writes to a file or ships logs to a server. It is a two-part system where the app emits traces over the network and a human watches them arrive.

The intended user is a developer debugging an app on a device or simulator. The README lists the reasons that developer would want it: filtering, log domains and levels, image and binary logging, message coloring, trace buffering, timing information, and links back to source code. Those are console features that IDEs either lack or bury. If your debugging loop is already comfortable inside Xcode's console, NSLogger is solving a problem you do not have.

How traces travel from app to viewer

The mechanism is a network connection, not a file. The README states that logs can be sent from a device or simulator, that the viewer accepts connections from local network clients using Bonjour, and that it also accepts remote clients connecting directly over the internet. The first log sent by an application starts the logger, and by default it attaches to the first Bonjour service it encounters.

That default creates a real problem on a shared network. The README is explicit: when multiple NSLogger users share a network, logger connections can get mixed. The documented fix is to call LoggerSetupBonjourForBuildUser() when the app starts, then type your user name into the Bonjour service name field on the Network tab of the viewer's Preferences pane, so traces are received only by the computer of the user who compiled the app. The README adds a constraint in italics: this only works when NSLogger was added using CocoaPods. A team using Carthage or Swift Package Manager does not get that isolation from the documented path.

Buffering is the other half of the design. Traces can be buffered in memory or in a file and sent to the viewer once a connection is acquired, which covers the case where the app runs before the viewer is open. The README also mentions opening raw buffered trace files brought back from client applications that were never directly connected, and exporting logs to text files. Connections use SSL by default, according to the feature summary.

Installing the viewer and the client framework

Installation has two independent halves. The desktop viewer is a pre-built, signed macOS application downloaded from the project's releases page. The README warns that it will not show a window until a client connects and starts logging, so an empty screen after launch is expected behaviour rather than a failure.

The client framework goes into your app. With CocoaPods, the plain pod includes the C and Objective-C APIs and suits applications with no Swift code:

ruby
pod "NSLogger"

Swift syntactic sugar is a separate subspec. The README notes you do not strictly need it, since you can write your own extensions over the C APIs:

ruby
pod "NSLogger/Swift"

There is a third variant for a specific linking problem. If frameworks or libraries in your build may use NSLogger, the linker can strip functions your own code never calls, so you force it to keep everything:

ruby
pod "NSLogger/NoStrip"

Carthage is the alternative path. The project builds two frameworks, NSLogger and NSLoggerSwift, and the README says to pick one and not both. Add the line below to your Cartfile, then run carthage update:

code
github "fpillet/NSLogger"
shell
$ carthage update

After that, add the built framework that suits your needs. The import differs by path: with CocoaPods you always write import NSLogger, while Carthage requires import NSLogger or import NSLoggerSwift depending on the framework you chose.

On iOS 14 and later, local network access needs permission. The README says to add these keys to Info.plist for development builds:

xml
<key>NSBonjourServices</key>
<array>
  <string>_nslogger._tcp</string>
  <string>_nslogger-ssl._tcp</string>
</array>
<key>NSLocalNetworkUsageDescription</key>
<string>Access to the local network for development builds</string>

For a first real use, the README states that without any change to your code, all NSLog() logs from your application are redirected to the viewer, which is found automatically on the network using Bonjour. So the shortest path is: launch the viewer, run your app, and watch the existing NSLog() output appear. The richer API comes after. The Swift wrapper logs a message with a domain and a level, and the same call shape handles an image or a data object:

swift
import NSLogger

Logger.shared.log(.network, .info, "Checking paper level…")
Logger.shared.log(.view, .noise, myPrettyImage)
Logger.shared.log(.custom("My Domain"), .noise, someDataObject)

The Objective-C wrapper uses predefined macros for common domains, as in LoggerApp(1, @"Hello world! Today is: %@", [self myDate]) and LoggerNetwork(1, @"Hello world! Today is: %@", [self myDate]).

Where NSLogger is the wrong tool

The clearest limitation is that NSLogger is a development instrument, not infrastructure. Nothing in the README describes a server component, retention policy, alerting, or a query interface over historical logs. If you need to answer a question about what happened in production last Tuesday, this is not the system that holds the answer.

The Bonjour model has a second cost. The default behaviour attaches to the first Bonjour service encountered, and the documented way to avoid cross-talk between developers on one network depends on CocoaPods. On a shared office network with mixed dependency managers, the isolation described in the README is not available to everyone. You can work around it with remote connections over the internet.

The release history is also worth reading carefully. The most recent release listed is v1.9.7 from 2019-01-09, with v1.9.6 and v1.9.5 in the weeks before it. The repository's last push was on 2026-06-03, so work has continued since that tag, but the README does not document what is in the unreleased state or how stable it is. A team that pins dependencies to tagged releases is depending on code from 2019.

Finally, the platform split is uneven. The README describes client applications on macOS, iOS and Android, but the viewer is a macOS application, and the repository also carries an iPad Viewer directory. If your team is not on macOS, the primary workflow does not apply.

NSLogger against SwiftyBeaver and other logging libraries

The obvious comparison is SwiftyBeaver. The difference is architectural rather than a matter of features. SwiftyBeaver is a Swift logging library whose destinations are configured in code: you add a destination and logs go there, whether that is the console, a file or a remote endpoint. It lives entirely inside your application process.

NSLogger inverts that. The client is a thin emitter and the intelligence sits in a separate macOS viewer that connects over the network. That is why NSLogger can show you images, binary payloads, colored messages and timing information in a filtering UI, and why it can buffer traces on the device until a viewer appears. It is also why NSLogger needs Bonjour, local network permission on iOS 14 and later, and a running desktop app before you see anything.

So the choice is about where you want to look at logs. If you want logs to flow to a file or a backend with no desktop dependency, a library like SwiftyBeaver fits better. If you want an interactive viewer that can display an image your app logged and let you filter by domain and level while the app runs on a device, NSLogger's split design is the reason it works.

Maintenance, licensing and upgrade cost

The repository is not archived and its last push was on 2026-06-03, so the codebase is not abandoned. That said, the release cadence visible in the release list stopped in 2019. Treat the tagged releases as the stable surface and the master branch as something you would need to evaluate yourself.

Upgrade cost is mostly about the dependency manager. Moving between CocoaPods and Carthage changes the import line and which framework you link, and the Bonjour-per-user isolation only works on the CocoaPods path. Choosing the NoStrip variant is a build-time decision that affects binary size, so it should be a deliberate one rather than a default. On iOS, adding the local network keys to Info.plist is a per-target change that must be repeated for every app that logs.

The repository carries a LICENSE.txt file and the metadata reports the licence as NOASSERTION, meaning no standard licence identifier was detected. Before shipping NSLogger inside a distributed application, read LICENSE.txt and confirm the terms with whoever handles licensing on your team; nothing here should be read as legal advice.

Editorial conclusion

Adopt NSLogger if you debug iOS, macOS or Android apps and want device logs, images and binary payloads in a desktop viewer instead of an IDE console. Do not adopt it if you need a server-side log pipeline, long-term retention, or a client for a platform the repository does not cover. Before wiring it into a project, verify three things: which pod variant you need (NSLogger, NSLogger/Swift or NSLogger/NoStrip), whether your build must add the NSBonjourServices and NSLocalNetworkUsageDescription keys to Info.plist for iOS 14 and later, and whether the last push, on 2026-06-03, corresponds to a tagged release you can depend on, since the newest release listed is v1.9.7 from 2019-01-09.

Frequently asked questions

What is NSLogger used for?

NSLogger displays traces emitted by client applications running on macOS, iOS and Android, replacing console logging such as NSLog() and Java Log. Its macOS viewer replaces the Xcode, Android Studio or Eclipse consoles and adds filtering, log domains and levels, image and binary logging, and trace buffering.

Does NSLogger work without changing my logging code?

The README states that without any change to your code, all NSLog() logs from your application are redirected to the NSLogger desktop viewer, which is found automatically on the network using Bonjour.

How do I install NSLogger in a Swift project?

With CocoaPods, add pod "NSLogger/Swift" to your Podfile; the plain pod only includes the C and Obj-C APIs. With Carthage, add github "fpillet/NSLogger" to your Cartfile, run carthage update, and pick either the NSLogger or NSLoggerSwift framework, then import the matching one.

Why does NSLogger need local network permission on iOS 14 and later?

Since iOS 14, apps must request permission to access the local network. The README says to add the NSBonjourServices array with _nslogger._tcp and _nslogger-ssl._tcp, plus NSLocalNetworkUsageDescription, to Info.plist for development builds.

Can several developers use NSLogger on the same network?

By default the first log starts the logger on the first Bonjour service encountered, so connections can get mixed. The README documents calling LoggerSetupBonjourForBuildUser() at app start and typing your user name into the Bonjour service name field in the viewer's Network preferences, and notes this only works when NSLogger was added using CocoaPods.

Official sources

  1. fpillet/NSLogger on GitHub
  2. Issues
  3. README
  4. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/fpillet-nslogger.svg)](https://hysenlabs.com/projects/fpillet-nslogger)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/fpillet-nslogger.svg)](https://hysenlabs.com/projects/fpillet-nslogger)

Was this useful?