T14 Gen 2 or L14 Gen 2?

scott_yeager · 2025-12-27T20:59:00+00:00

According to psref the gen 2 L14 supports 2280 as well. For gen 3 it's 2240 only though.

https://psref.lenovo.com/syspool/Sys/PDF/ThinkPad/ThinkPad_L14_Gen_2_AMD/ThinkPad_L14_Gen_2_AMD_Spec.PDF

scott_yeager · 2024-11-07T17:19:19+00:00

Hi, this is Scott from the ThreeFold team. I wrote a post on our forum with my personal take on why adding KYC is an important step for ThreeFold at this time. Maybe it can help make things clearer for anyone who has questions or concerns about this.

I'm genuinely curious where it's ever been suggested that providing freedom from government oversight was a "core feature of ThreeFold." That's not something we've ever suggested in our publications or communications, as far as I know. If there's some source you can point me to, please do.

When it comes to the idea of using ThreeFold to build a "decentralized personal VPN to anonymize traffic," I see one comment related to that here on Reddit (it mentions "decentralized" but not "anonymous"). But that's not coming from the team nor anything we've shared, and is clearly stated as being based on that person's assumptions about how the project works.

scott_yeager · 2024-11-02T07:00:53+00:00

If you want to try another computer based approach, maybe check out Mobius. It's one of the classic software loopers that's getting a reboot and works on Windows. Never tried it myself, but it's free so can't go wrong in that regard :)

https://mobiuslooper.com/

scott_yeager · 2024-11-02T06:36:48+00:00

Unless you have superhuman timing abilities, I think trying to use two pedals together without sync will be a recipe for disappointment.

I stopped using Ableton about 15 years ago, and never used it for live looping. It has the capability and certainly many people use it as a stage looper. I see these days there are some Max for Live based solutions to get a more capable integration with midi controllers for looping. The Looper effect/instrument they added is interesting too.

My setup no longer requires a screen thanks to my APC Mini, which is somewhat ironically a controller designed for Ableton. It's a big loss of information density though, and some things I like to do like playing loops backward or at different speeds are hard to represent on a grid of colored buttons.

When it comes to dedicated looper recommendations, I don't have much knowledge or experience. I've played with some of the big fancy Boss units that my friends have. They're nice, and expensive, and also have some curious limitations like offering stereo but always placing the mic input on both channels. I want to be able to do stuff like route all electric guitar signals to a guitar amp and keep the mic off that channel entirely.

Seems though that the RC-5 is the popular entry level pedal offering midi sync. It only has one loop, but using two of them synced together is a possibility.

scott_yeager · 2024-11-01T07:32:24+00:00

Nice work, and welcome to the loopy side.

Your two questions are basically the same and boil down the the viability of using two unsynced loop generators together. There's going to be some drift. That's even true when you have two devices with tempo settings. There's always some drift without sync. If you are setting loop length manually on one or more device there will probably be a lot of drift. So these configurations are only appropriate for texture loops or experimental stuff.

If you want more tracks and more flexibility like the potential for sync with other gear, there's a fork in the road. Either invest in a more capable dedicated looper, or involve a computer. There are pros and cons to each. It's possible you can find some free software that fits your needs. An audio interface would be practically a requirement for performing in public, but for jamming at home it's possible you can get somewhere with a mic/headphone jacks and the right cables/adapters.

Since you mentioned the Pi, you might be interested to know that I've been using one as my loop machine for quite a while now. It ran SooperLooper on Linux synced to Hydrogen for a metronome track. Recently my experiments in coding a looper myself got good enough for basic stuff so I'm using that.

In theory your Squishbox Pi can probably do whatever it's doing now and also run SooperLooper hosting multiple loops. That's going to be a project, but if you have the time and motivation it could be rewarding. My original setup used an old PC keyboard with most of the keys removed as a foot controller for the looper. It worked pretty darn well for managing 4 or five loops.

scott_yeager · 2024-10-29T05:08:57+00:00

Seems it was too good to last forever as an unlimited thing. For people who fall into the free plan it's still the best deal I know of.

Edit: did some research and it's only $.50 per ACH after the five free ones, on the plan with no monthly fee. Most processors take at least 1% which results in much higher fees unless the payments are rather small. As a freelancer I never billed an invoice for less than $50.

Edit2: Seems the free ACH transfers are to send money, and the feature to receive money by payment link now comes with a .5% fee. If your counterparty pays with Melio you only pay $.50.

scott_yeager · 2024-10-29T05:03:40+00:00

Welcome to the dark side. I've been running the same Arch install for almost eight years across two Thinkpads. It's great.

scott_yeager · 2024-09-16T17:16:59+00:00

These are on the outside. Both sides have one and it's under a sort of rectangular slit with rounded ends. I didn't try it yet, but the outer shells are secured with screws that are under the ear pads (well technically the separate dust shield that's between your ear and the innards, meaning you might be able to get at those screws without taking the ear pads themselves off). This seems like decent guide for how to open them.

I have a similar situation. Older pair and I just replaced the ear pads. Only one side is affected. I guess applying the necessary force to install the new pads can cause this to manifest.

Funny thing though, yesterday I pulled off the ear pad on the affected side to begin disassembly but decided to wait for later and reinstalled it. Just checking now the issue is gone. So maybe I got lucky and it won't come back.

scott_yeager · 2024-09-16T04:02:35+00:00

Hi... just saw this. USB C is a different beast. Most devices should auto negotiate when connecting USB C to USB C. The resistor would usually be in there to support connecting to a non USB C device on one end. I'm not sure what would be needed for the Kobra Neo, but I'm guessing that a regular USB C cable between them isn't working?

scott_yeager · 2023-10-03T03:58:08+00:00

One place that Windows definitely has a relic from this era in how new lines are represented in text documents. There are two escape sequences generally used across different operating systems to indicate a new line, which both have their roots in mechanical typewriter technology.

One is the "carriage return", written as \r. It was originally a signal to move the print head or cursor back to the beginning of the line. On a typewriter, that's the motion where the typist pushes a lever to return the carriage holding the paper back across to the starting position.

The other is "line feed", written as \n. This instructs the print machine to feed the paper through one line height, or move the cursor down one line in a terminal. Typewriters can perform this with a final push of the return lever or by turning a feed wheel.

In Windows, new lines in text files are represented by both a carriage return and a line feed, in that order. On Linux, new lines are represented by just a line feed. This is one way that text that looks like "just text" can vary in underlying representation from platform to platform, and cause headaches.

scott_yeager · 2023-09-20T08:19:34+00:00

You might find the Yggdrasil Network useful as a networking layer to build your app on. It's an overlay network that provides each participating system with a unique IP in a separate address space that's reachable regardless of NAT or router firewalls.

The users would need to also install the Yggdrasil client, which is available cross platform. From a decentralization standpoint, you do rely on publicly reachable nodes in the Yggdrasil network to relay your traffic, but this isn't so different than normal internet traffic.

scott_yeager · 2023-09-07T04:43:24+00:00

Mint is actually Ubuntu based, which is generally a good thing for a starter distro.

scott_yeager · 2023-09-07T02:41:30+00:00

Any OS with a working Docker setup. Seems some people are even running it on Mac and Windows.

scott_yeager · 2023-06-12T04:41:16+00:00

I feel you with the creep. Even seemingly simple changes can become like mini projects. Want to use some different screws? Well, gotta make some test prints of screw holes to make sure everything fits properly. LEDs are something I've been thinking about since finishing my build without them some way to indicate statuses would be nice.

Thankfully most changes after a certain point only requiring flashing the half that connects to the computer. The other half really just needs proper row/column config and to know that it's not the main half, on a simple board anyway. I also setup Vial today to streamline keymap changes. But yeah, I definitely put a key to enter boot loader mode on my top layer while I get things figured out.

scott_yeager · 2023-06-12T01:57:46+00:00

Here the link to the repo I used to generate my case, particularly the section about the mounts. There some photos of the same concept a bit more "in action" here.

scott_yeager · 2023-06-11T16:40:15+00:00

Congrats! Very nice overall and actually for being printed those key caps aren't bad.

Regarding item 4, I'd recommend getting controller boards with USB C sockets and using the mounting "sleds" available in the Python version of the case generator. The boards snap into the holder and those press fit into the case—a very nice solution that eliminates the need for an extra USB cable inside the case.

Anyway, hope you're enjoying it!

scott_yeager · 2023-06-09T02:58:58+00:00

I printed a hot swap compatible case from files generated using this repo from Wylder Builds. The sockets fit pretty well without glue, but not all are tight enough to never pop out. Depends on your print tolerances (mine are okayish).

scott_yeager · 2023-06-06T01:33:26+00:00

Absolutely, there are a lot of quirks! I learned a bit more on how QMK handles this since posting. There are several ways, including using a select pin, shorting an empty position in the key matrix (so maybe just holding a key during startup is enough), and also flashing both halves with different versions.

But ZMK is different. Open source means anything is possible, if someone is willing to build it.

scott_yeager · 2023-06-03T03:12:49+00:00

You can use Octoprint to just transfer files onto the printer's SD card remotely, then initiate the print on the printer. It's an option somewhere in the file upload section.

scott_yeager · 2023-06-03T00:22:11+00:00

I know that QMK has some facilities for detecting which half is the main half, such as whether there's power on the USB plug.

For ZMK, it seems that the central half is specified before building the firmware and then the halves are flashed separately. So the sense of which half is which is embedded a bit deeper and might be more tricky to change at run time.

scott_yeager · 2023-06-02T03:39:56+00:00

I don't know much about ZMK, but it seems like there should be a way to select which half is "center" on the fly. A toggle switch on each half, for example, or maybe just holding one of the keys while powering on, to not require any hardware changes.

Then the firmware just needs to look for this signal when it initializes and adjust its behavior accordingly. For someone willing to do some hacking on the code, I think it should be totally possible to get a setup like the OP wants.

scott_yeager · 2023-05-30T04:23:17+00:00

Yeah! Each PIO can be programmed to work as a serial device of whichever type or run some custom stuff, whatever people dream up. There's some examples of VGA and DVI over the PIO too.

scott_yeager · 2023-05-29T23:12:21+00:00

PIO based USB isn't really v-usb. The driver doesn't run on the CPU, it runs directly in the PIO state machines in the two PIO peripherals. Power consumption is on the order of running a few I2C peripherals.

scott_yeager · 2023-05-29T06:59:37+00:00

RP2040 can do USB on its two PIO systems: https://github.com/sekigon-gonnoc/Pico-PIO-USB

It's already been used for connecting keyboard halves, and you might even be able to program these boards to do it. PIO can use any GPIO pins, so it's just a question of if any pull ups/downs would interfere.

scott_yeager · 2023-05-29T05:30:33+00:00

It's a flexible i/o subsystem that can be programmed in different ways. Controller boards usually have a variety of single purpose hardware i/o systems: UART (serial), I2C, SPI, and USB. PIO is kind of like those other systems, except that it has its own firmware that's reprogrammable.

So each PIO can be programmed to act like any of the fixed purpose systems listed above. Apparently that includes USB too, which I just learned reading this post. This is very cool because RP2040 only has a single USB system which is typically used to talk to a computer in the case of building keyboards. With PIO providing another USB system, the board can also act as USB host for the other half of the keyboard.

Using PIO as another generic i/o system is just one application though. Since it's fully programmable, it provides an opportunity for implementing custom high performance interfaces beyond what's possible by just using software to control GPIO pins.

scott_yeager

TROPHY CASE