Forem: Collins Ruto

Fix: Qualcomm QCNFA765 WiFi Disappears After Suspend on Arch Linux (Hyprland)

Collins Ruto — Wed, 11 Feb 2026 11:55:36 +0000

Intro

If you're running Arch Linux (especially with Hyprland) and your WiFi works after boot but disappears after locking or suspending, this post is for you.

This issue affects systems using:

Qualcomm QCNFA765
Kernel driver: ath11k_pci
NetworkManager + wpa_supplicant
GRUB managed by another distro (e.g., Ubuntu in a triple boot setup)

The Problem

WiFi works normally after reboot.

But after:

Locking the system
Suspending
Disconnecting and reconnecting

You get:

nmcli device wifi connect <ssid> --ask → timeout
nmcli device → no WiFi device listed
ip link → no wlan0 or wlp*
rfkill list → not blocked

The WiFi interface disappears completely until reboot.

Diagnosis

Check your WiFi chipset:

lspci -k | grep -A4 -Ei 'network|wireless'

If you see:

Qualcomm Technologies QCNFA765
Kernel driver in use: ath11k_pci

You're hitting a known power management bug.

Root Cause

The ath11k_pci driver sometimes:

Enters a deep idle power state (D3cold)
Fails to resume properly after suspend
The kernel drops the WiFi interface
NetworkManager can no longer see a device

This is a resume power-state issue with ath11k chipsets.

Temporary Fix (No Reboot)

Reloading the driver restores WiFi:

sudo modprobe -r ath11k_pci
sudo modprobe ath11k_pci

After that:

ip link

Your WiFi interface should return.

This confirms the issue is driver-related.

Permanent Fix

Disable ath11k Idle Power Saving

Add this kernel parameter:

ath11k_pci.disable_idle_ps=1

This prevents the driver from entering the unstable idle state.

If you use GRUB

Edit:

sudo nano /etc/default/grub

Find:

GRUB_CMDLINE_LINUX_DEFAULT="..."

Append:

ath11k_pci.disable_idle_ps=1

Example:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash ath11k_pci.disable_idle_ps=1"

Regenerate GRUB:

sudo update-grub

Verify:

cat /proc/cmdline

You should see:

ath11k_pci.disable_idle_ps=1

Done.

Alternative: Auto-Reload Driver on Resume (Arch Only)

If you prefer not to modify GRUB, create a resume hook.

Create:

sudo nano /usr/lib/systemd/system-sleep/ath11k-resume

Add:

#!/bin/sh
case "$1" in
  post)
    /usr/bin/systemctl restart NetworkManager
    /usr/bin/modprobe -r ath11k_pci 2>/dev/null
    /usr/bin/modprobe ath11k_pci
    /usr/bin/systemctl restart NetworkManager
    ;;
esac

Make executable:

sudo chmod +x /usr/lib/systemd/system-sleep/ath11k-resume

Now WiFi will recover automatically after suspend.

Summary

Issue	Cause	Fix
WiFi disappears after suspend	ath11k idle power-state bug	Disable idle power saving
`ip link` shows no wlan device	Driver failed resume	Reload `ath11k_pci`
nmcli timeout	No kernel interface	Fix power state

Final Thoughts

This issue can be confusing because:

NetworkManager looks broken
nmcli times out
No device appears
Reboot "magically" fixes it

But the real culprit is ath11k power management during suspend.

If you're running Hyprland on Arch with Qualcomm WiFi and experiencing this, hopefully this saves you a few hours.

Happy hacking 🐧

GitHub SSH for Linux & ALX SandBox

Collins Ruto — Mon, 26 Jun 2023 20:53:01 +0000

Introduction

GitHub SSH (Secure Shell) is a secure protocol used to establish a secure encrypted connection between a local machine and GitHub's remote servers. It allows you to securely authenticate and communicate with GitHub without relying github token and also since passwords deprecated and unsuported.

When using SSH with GitHub, you generate a key pair consisting of a public key and a private key. The public key is stored on GitHub, while the private key remains on your local machine. The private key should be kept confidential and protected with a passphrase.

Sandbox/Terminal setup

To begin, go to your ALX Sandbox and run your sandbox through your preferred method.

Generate SSH key

To generate your ssh key, run the following command on your sandbox/terminal.

ssh-keygen -t ed25519 -C "your_email@example.com"

You will be prompted to Enter a file in which to save the key, press enter to save in the default location. You will then be prompted to enter a passphrase, just press enter or input one and repeat the same if you prefer it.

Get your SSH key

The generated SSH key is now stored in the ~/.ssh/id_ed25519 directory. To access the new SSH public key, run the command below then select and copy the output.

cat ~/.ssh/id_ed25519.pub

Copy this value as it is required for later steps in setting up GitHub.
The output should something similar to:

ssh-ed25519 Some-long-string-of-characters-here your-email@gmail.com

GitHub Setup

Now we need to add our generated SSH public key to GitHub account.
Click here and you will be directed to your GitHub new SSH Keys page.

Alternatively, go to your GitHub account settings and navigate to the "SSH and GPG keys" section and click on "New SSH key".
You should see a similar page.

On mobile phones, scroll down to the section.

On the Title input field, give your ssh key a name e.g "ALX-Sandbox".

Thereafter on the key input field, paste the public key that we copied from the sandbox output.

Click Add SSH key.

You will be prompted to enter you GitHub account password to authorize adding the Key.

Update your git identity

If you haven't updated your git identity on your sandbox/terminal before, do the following commands and be sure to substitute with your actual username and email:

git config --global user.email "you@example.com"
git config --global user.name "Your Name"

This helps to create a local git profile for local git commits and activities.

3 Test

Now that we have successfully added our public key to github, we have to test our connection.

Open up your sandbox and run the following:

ssh -T git@github.com

This attempts to connect to GitHub via ssh. If everything is set correctly, it would return something like this:

The authenticity of host 'github.com (IP ADDRESS)' can't be established.
ED25519 key fingerprint is SHA256:+....> Are you sure you want to continue connecting (yes/no)?

Type yes on the terminal to confirm.

You are now connected!

Using SSH

Lets try using the new ssh in a real project.

Firstly create a new repository here: new empty repository and give a name and optional description.

Do NOT select add README file, .gitignore or license.

click on 'create repository'.

Cloning the repository

You will be navigated to the created repository page. Click on the ssh tab as shown below arrow 1:

Copy the preceding git ssh url, substituting for your username and the name of your repository. Which in the case of the screenshot above is like so on arrow 2:

git@github.com:your-username-here/repo-name-here.git

On your terminal/sandbox, clone the repo by running the following, substituting for your username and the name of your repository:

git clone git@github.com:your-username-here/repo-name-here.git

This should create an empty directory with name repo_name_here inside it. You may now make changes to your project as you wish and push them to GitHub directly. Go to your repository and refresh the page to confirm changes.

If you are asked to authorize your SSH key after running git push as such:

The authenticity of host 'github.com (IP ADDRESS)' can't be established.
ED25519 key fingerprint is SHA256:+....> Are you sure you want to continue connecting (yes/no)?

Type yes on the terminal to confirm.

You are now connected and your changes will be pushed.

Add Google Analytics to Next.Js 13.4 app dir

Collins Ruto — Sat, 03 Jun 2023 14:10:26 +0000

Intro

Google Analytics is a powerful web analytics tool that provides valuable insights into your website traffic and monitor user behavior. Integrating Google Analytics into your Next.js application allows you to track and analyze user interactions, measure marketing campaign effectiveness, and make data-driven decisions. We will explore the steps to set up Google Analytics (gtag.js) in a Next.js application.

Google analytics account setup

First, visit the Google Analytics Website and sign up using your google account.
Start the Account setup then create a new property for your Next.js application and provide the details asked. After completing the setup, you will be taken to a new platform page for your account.
Select the platform for your project, in this case that will be web.

Enter the website url of where you next app is hosted and give a prefered name. Click on create stream to continue.

Once the property stream created, you will be taken to a page similar to the one below. Note down the Property ID. It should be in the format G-XXXXXXXXX.

Initialize Next.js project

Setup your Next.Js project as per https://nextjs.org/ specifications.

This should work just fine:

npx create-next-app@latest your-next-app

Environment variables

In the root directory of your project, you should have an environment .env.local file. If that is not the case, you can create a file by the same name. Add your property ID that we copied earlier here.

NEXT_PUBLIC_GOOGLE_ANALYTICS= 'G-XXXXXXXX'

Create a google analytics Component

Create a components folder or any folder of your choice outside of the app directory and within your project directory, preferably within the src directory. In the components folder create a GoogleAnalytics.tsx file.
In the file copy the code below and save it.

import Script from "next/script";

const GoogleAnalytics = ({ ga_id }: { ga_id: string }) => (
  <>
    <Script
      async
      src={`https://www.googletagmanager.com/gtag/js? 
      id=${ga_id}`}
    ></Script>
    <Script
      id="google-analytics"
      dangerouslySetInnerHTML={{
        __html: `
          window.dataLayer = window.dataLayer || [];
          function gtag(){dataLayer.push(arguments);}
          gtag('js', new Date());

          gtag('config', '${ga_id}');
        `,
      }}
    ></Script>
  </>
);
export default GoogleAnalytics;

Render the component in the Layout file

In the root layout.tsx file in the app directory, import your GoogleAnalytics component like so:

import GoogleAnalytics from "~/components/GoogleAnalytics";

You can then modify your code to match the format below.

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
      <html lang="en">
        <body>
          {process.env.NEXT_PUBLIC_GOOGLE_ANALYTICS && (
            <GoogleAnalytics ga_id= 
            {process.env.NEXT_PUBLIC_GOOGLE_ANALYTICS} />
          )}
          // ... your other code content here.
        </body>
      </html>
  );
}

Run your app

On your terminal, run the following to start your app.

npm run dev

On the browser, navigate to your next app live url, most likely it will be http://localhost:3000
Open the browser console.
On the console, type datalayer. If you see an output similar to the one below then, Yaay 🎉 you did it!

Host your app

If you are planning to host your site, be sure to add your property in your hosting service project settings. You should find the environment variables settings and add you ID with the same keyname as used in the project .env.local file.

You can now go to the analytics dashboard and click on the live button, where you will see the information about the application in real-time!

For any follow up or questions, reach out through any of the following:
My Personal website, My Blogs, Twitter, Github or linkedin

Sample github project:
https://github.com/collins-ruto/learnhq

Write response from a rust function to a file

Collins Ruto — Sat, 03 Dec 2022 06:22:38 +0000

If you want to save the response from a function for later, you can use the std::fs::write function to write the response to a file on your local file system.

For example, suppose you have a Rust function named my_function that returns a String containing the response you want to save. You can use the following code to write the response to a file named response.txt:

use std::fs;

fn my_function() -> String {
    // function body goes here
}

fn main() {
    let response = my_function();

    fs::write("response.txt", response).expect("Failed to write response to file");
}

This will create a new file named response.txt in the current directory, and write the response from the my_function function to the file. If the file already exists, it will be overwritten with the new response.

You can then use the std::fs::read_to_string function to read the saved response from the file at a later time:

use std::fs;

fn main() {
    let response = fs::read_to_string("response.txt").expect("Failed to read response from file");

    // use the response here
}

I hope this helps! Let me know if you have any other questions.

Send a HashMap as parameters to a rust smart contract

Collins Ruto — Sat, 03 Dec 2022 05:57:20 +0000

To send a HashMap as a parameter to a Rust function from the near-cli, you can use the --arg flag to specify the key-value pairs of the map as command-line arguments. The --arg flag takes two arguments: the key and the value, separated by a = sign.

For example, suppose you have a Rust function named my_function that takes a HashMap<String, String> as an argument. You could call this function from the near-cli using the following command:

near call <contract_name> my_function --arg key1=value1 --arg key2=value2

This would pass a HashMap with two entries to the my_function function, where the keys are "key1" and "key2", and the corresponding values are "value1" and "value2", respectively.

Inside the my_function function, you can access the HashMap argument using the std::env::args method, which returns an iterator over the command-line arguments passed to the function. You can then use the Iterator::filter method to filter the arguments for those with the --arg flag, and the Iterator::map method to map each argument to a tuple containing the key and value. Finally, you can use the Iterator::collect method to collect the tuples into a HashMap:

use std::collections::HashMap;
use std::env;

fn my_function(map: HashMap<String, String>) {
    // function body goes here
}

#[near_bindgen]
impl MyContract {
    pub fn call_my_function() {
        let args: Vec<String> = env::args().collect();
        let map: HashMap<String, String> = args
            .iter()
            .filter(|arg| arg.starts_with("--arg"))
            .map(|arg| arg.split("=").collect::<Vec<&str>>())
            .map(|parts| (parts[0].to_string(), parts[1].to_string()))
            .collect();

        my_function(map);
    }
}

I hope this helps! Let me know if you have any other questions.

Survey Form

Collins Ruto — Wed, 30 Mar 2022 17:06:33 +0000

Web Tribute To Nelson Mandela

Collins Ruto — Wed, 30 Mar 2022 16:09:04 +0000

Product landing page

Collins Ruto — Wed, 30 Mar 2022 16:06:38 +0000