When using Codex, whenever a complete conversation turn ends or when execution permission is requested, macOS's Notification Center immediately pushes a notification to me.

At first, I didn't delve deeply into how this feature was implemented, until I used Codex through tmux and discovered that notifications had completely disappeared. This sparked my curiosity. Why is this happening?

When experiencing various large models, managing configurations for different AI platforms (securely storing API keys) becomes a burden. However, if you use home-manager to manage dotfiles like me (which ensures consistent software and configuration across multiple devices), I recommend encrypting API keys with age and mounting the decrypted tokens as files during rebuild. Then use pkgs.writeShellScriptBin to wrap the original commands and configure the corresponding environment variables.

Usage

# Run claude-code with subscription
claude

# Run claude-code with ZhiPu's large model
zhipu

# Temporarily run claude-code with ZhiPu's fast model
ANTHROPIC_MODEL=glm-4.5-x zhipu

Introduction

Recently, while writing Golang code, I needed to isolate certain constants in the code during the build process by using Golang's built-in build tags feature. To achieve this, specific startup parameters for gopls must be configured for correct code indexing. However, gopls configuration needs to be done at the project level, as global configuration might interfere with other projects.

So, how can we configure it?

Setting Up a Basic Cross-Platform Rust Build Environment with Nix Flake

1. Add a flake.nix file and run git add flake.nix:

   {
     inputs = {
       utils.url = "github:numtide/flake-utils";
       nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";
     };
   
     outputs = {
       nixpkgs,
       utils,
       ...
     }:
       utils.lib.eachDefaultSystem (system: let
         pkgs = import nixpkgs {inherit system;};
         lib = pkgs.lib;
       in {
         devShells =
           {
             default = pkgs.mkShell {
               nativeBuildInputs = with pkgs; [
                 pkg-config
                 gcc
               ];
             };
           }
           // builtins.listToAttrs (map (target: {
             name = target;
             value = let
               cross = import nixpkgs {
                 inherit system;
                 crossSystem = {config = target;};
               };
               cpkgs = cross.pkgsMusl;
             in
               cross.mkShell {
                 nativeBuildInputs = with pkgs; [
                   pkg-config
                   gcc # Required for compiling proc macros and other dependencies
                 ];
                 env = let
                   normalized = lib.strings.toUpper (builtins.replaceStrings ["-"] ["_"] target);
                 in
                   with cpkgs; {
                     # https://doc.rust-lang.org/cargo/reference/environment-variables.html#configuration-environment-variables
                     "CARGO_TARGET_${normalized}_LINKER" = "${stdenv.cc.targetPrefix}cc";
                   };
               };
           }) ["x86_64-unknown-linux-musl" "aarch64-unknown-linux-musl"]);
       });
   }
   

2. Build the project:

   # Local build
   nix develop .#default --command \
     cargo build
   
   # Cross-platform build
   #
   # Ensure the required Rust targets are installed:
   # rustup target add aarch64-unknown-linux-musl
   # rustup target add x86_64-unknown-linux-musl
   
   nix develop .#x86_64-unknown-linux-musl --command \
     cargo build --target x86_64-unknown-linux-musl
   

Handling C/C++ Dependencies (e.g., OpenSSL, PQ)

Use static linking and vendor-based bindings (which package C/C++ source code) to ensure stable and reproducible builds.

1. Add target-specific dependencies in Cargo.toml:

   [target.x86_64-unknown-linux-musl.dependencies]
   openssl-sys = { version = "0.9", features = ["vendored"] }
   pq-sys = { version = "0.7", features = ["bundled"] }
   
   [target.aarch64-unknown-linux-musl.dependencies]
   openssl-sys = { version = "0.9", features = ["vendored"] }
   pq-sys = { version = "0.7", features = ["bundled"] }
   

2. Build the project:

   # Static linking may require setting RUSTFLAGS.
   # However, this setting may not work for all architectures.
   RUSTFLAGS='-C target-feature=+crt-static' cargo build
   
   # x86_64-unknown-linux-musl enables crt-static by default, so no extra flags are needed.
   TARGET=x86_64-unknown-linux-musl nix develop .#$TARGET --command \
     cargo build --target $TARGET
   

CRT stands for the C runtime. The default crt-static setting varies by target. For example, x86_64-unknown-linux-musl enables it by default, whereas arm-unknown-linux-musleabi does not. ¹

Recently, I've been working on a large project in Rust, but my laptop isn't powerful enough to handle it efficiently. So, I decided to buy a new mini-PC specifically for this task.

Since I’m still more accustomed to developing on macOS and didn’t want to go through the hassle of setting up a Hackintosh, I decided to install NixOS on my new mini PC. Initially, I planned to continue using VSCode for remote development, but later realized that Neovim is also a great option.