Welcome to guest Zeldstarro, a semi-furred dragon that likes geography and travel and also writes about furry event mapping.
You may remember Dogpatch Press previously reporting on Furry Studies and their two international conferences, held in the Netherlands in 2024, then Washington State in the US in 2025. For those who don’t remember, or are stumbling into this post, Furry Studies is an academic conference that aims to add more research from and about the fandom, as well as opening more research avenues more generally. Unlike Furscience, which is a group of researchers that conducts its own research, Furry Studies instead hosts or publishes research. Think about it like panels in a furry convention – while Furscience (for example) may host a panel at, say, 4pm on Saturday, Furry Studies would be responsible for booking the meeting room with the venue itself.
The next conference will take place in July 2027, on the Wednesday and Thursday preceding Aurawra, a furry convention. More specifically, it will be in Parramatta (basically Sydney) in New South Wales, Australia (with online streaming). Since Aurawra’s exact dates are yet to be determined, the same holds true for Furry Studies.
However, the “Call for Proposals” is in effect and is on the Furry Studies website! This year’s theme is Feeling the ‘fur’.
The first theme in 2024 was What does it mean to be furry?, and the second year focused on furry worldbuilding on the global stage. For the third iteration, Furry Studies asks: “How do furries use fursuits, fursonas, and the feeling of ‘fur’ to navigate identity, belonging, and collective creativity?”
Put briefly, there are two main categories for proposals: academic papers and community talks.
Papers are research presentations, though the particular length is shorter than I, personally, was expecting: 500-1000 words. In a more traditional academic setting, this would be submitted with the expectation that a longer, more thorough paper would be submitted to a professional journal, though that’s not yet the case for Furry Studies. Keep in mind, you do not have to be in university to contribute to academia! You will need to submit the paper proposal and describe your aim, finding, and a brief discussion, which will be peer reviewed.
Community talks are also presentations about various furry things without basing itself on academia as strictly as the other category. There is plenty of “furry knowledge” that may be difficult to share otherwise in this context, so this is a great opportunity to present these kinds of topics in an academic setting. The submission for this will be 300-1000 words, and leans more towards presentation than paper.
The deadline for submissions is the 8th of January, 2027, which means that you have about 3 months to make your submissions. Every submission is peer reviewed, including at least one researcher from Furry Studies, so you won’t know the actual decision until the 5th of February.
I’m exhausted. Wiped. Drained. Pooped. Stick a fork in me. I have barely enough in me to write this. I’ve been partying every single weekend this summer, and it’s furry’s fault. Toronto’s furry community has popped off this summer, and I’m incredibly proud (but also eepy). It may have to do with the fact that fewer Canadians are crossing the border, and they’re looking to fill their FOMO from the big US cons that would typically fill a summer schedule and budget.
Please note that this blog covers the events I or close friends were able to attend, and is not a comprehensive list of every single furry event in Southern Ontario. This does not cover fursuit walks, or small scale furmeets, which are also hosted frequently. I can’t remember a summer this busy in my 18 years of being a part of this community. It’s been a good year to be a furry in the greater Toronto area.
Raves raves raves
Since roughly May 2026, there has been one rave or another happening nearly every single weekend. And most of them have been selling out, at increasingly larger venues.
Feral Frequency
Tail Gate
Muzzled
Bark in the Dark
Faunaesthetic (Hamilton)
Steel City Beasts (Hamilton)
Spike!party
I’m getting burnt out on raves. I rarely go to the dance parties for the music, I’m more there for the company and the vibes. I am however partial to the events that are in walking distance from my house. I’ve been honored to host pre-drinks and walk a big group of kink-gear clad friends over to the venue. On one occasion, an event sold out within 3 minutes, and we were unable to get tickets; so instead we hosted a parallel party. Some folk joined us to pre-game, but half of us stayed behind to listen to records and cuddle on the couch. After one event we even dared to stay up late enough to host an after-party.
Dean Winters,aka the Mayhem dude, is an incredible and often surreal mimic who has impersonated both living and inanimate creatures and things as an Allstate insurance advertising spokesman. Those things have included dogs, cats, bears, raccoons, the Elf on the Shelf, a deer, Santa’s Helper, and many others. We haven’t seen Mayhem in a while, but now thankfully he’s back, this time as a decomposed limb on a 200-year old elm tree. As usual, Winters portrays the tree limb in his usual conservative suit, with no attention at all given to prosthetics or special effects. Mayhem doesn’t need them. He just hangs absurdly in defiance of gravity from a tree trunk…
Falling, Winters as a ” dead on the inside” major tree limb does major damage to a house that he’s situated by, crashing through the roof. “It just feels so good to let go!,” he remarks from the ground.If you don’t have the right kind of insurance, Winters tells us, this kind of thing could really wipe out your bank account. Laughing at the destruction he’s caused, Mayhem tells us he will find his own way out…
I think that Mayhem would be more than a match for any of the other insurance spokesmen, including Flo, the Gecko, the Limu Emu, and certainly the Liberty Biberty. This of course is just the humble opinion of a timid woodland creature…
Kindred Dragons is a new full-color graphic novel written and illustrated by Sarah Mensinga. “Alice has been unhappy ever since her parents sent her to Prince Edward Island to live with her strict grandmother. Alice is fanciful, prone to telling tall tales, and absolutely OBSESSED with dragons! Fairies deliver dragon eggs to a select few, known as Kindreds, but no egg has ever arrived for Alice. While wandering the woods alone, she finds and secretly befriends a mysterious old dragon named Brim. Alice is excited to finally have a dragon friend of her own, but when Brim suddenly falls ill, Alice must set out on a desperate quest to save him. As Alice searches for a cure, she discovers that her connection to dragons is unlike that of any Kindred—but will her new power be enough to save her friend?” Find out that and more, thanks to Abrams Books.
Six years ago, I wrote a blog post titled Soatok’s Guide to Side-Channel Attacks in which I discussed the general topic of side-channels in cryptographic applications, and how to avoid them, with example code in PHP. I had called out that the algorithms discussed on the page cannot rule out compiler or runtime optimizations that undermine your security goals: You can achieve algorithmic constant-time, but any higher assurance was outside the scope of the work being done.
For that reason, we’re going to assume that algorithmic constant-time is adequate for the duration of this blog post.
If your threat model prevents you from accepting this assumption, feel free to put in the extra effort yourself and tell me how it goes. After all, as a furry who writes blog posts in my spare time for fun, I don’t exactly have the budget for massive research projects in formal verification.
Soatok’s Guide to Side-Channel Attacks (Aug. 2020)
To make it easier to see in action, I also wrote a separate TypeScript / JavaScript library called constant-time-js for demonstration purposes.
Over the years, this demo code has been adopted by precisely zero dependent packages, according to NPM (at least, as of this writing).
My warnings to not rely on this in production worked! Art: AJ_LovesDinos
However, that only covers open source dependencies; I have no idea if some proprietary software decided to build on my designs.
My reason for posting an advisory and requesting a CVE is simple: If anyone is actually using this code (e.g., in a proprietary software system I have no visibility into), then either npm audit or a CVE being assigned is likely to trigger internal security mechanisms and prompt them to upgrade to the latest version as soon as possible.
Since the urgent stuff (advisory, patch, etc.) has already been handled elsewhere, I thought I’d write a blog post that dives deeper into the more interesting parts of this finding and its remediation.
Because, let’s be real, if you read my blog you’re either a nerd or part of a nerdy subculture, so why not nerd out a bit?
2026-08-21: Disclosure email received at 4:51 PM. I reply only to Yayu at 4:54 PM to say “Hey, I [got] your email. I’m currently traveling and will not be at a keyboard until Tuesday. I’ll follow up as soon as I can.”
2026-08-25: I verify the report and then write a patch.
2026-08-26: I reply-all to the disclosure email with a locally-tested proposed patch.
2026-09-09: Yayu responds that they tested the patch and confirmed it removed the leakage.
2026-09-10: Public disclosure and new version tagged.
2026-09-11: This blog post is written.
Though I didn’t post it until a little after 3 AM. Oops.
Verifying The Report
In the age of AI-driven vulnerability hunting–punctuated by severity inflation and frequent hallucinations–the proportion of bogus reports to legitimate ones has increased significantly. Verifying that the bug actually exists and is as severe as the researcher claims has always been important for maintainers, but it invites much more emphasis when you’re drowning in slop.
The initial report email was shared in the pull request description for the fix, if you want to read it in full. The relevant excerpt from the description tells us enough to figure out where to start looking:
The conditional-selection functions in constant-time-js use branchless JavaScript expressions to construct selection masks. We found that select, select_alt, and select_ints nevertheless produce secret-dependent instruction- and data-cache behavior in V8. The leakage arises from V8’s ToBoolean mechanism, its different handling of -0 and -1, and direct accesses to the raw true and false Oddball objects on different cache lines. The resulting cache-access patterns can reveal the value of the selection condition.
Yayu’s disclosure email
So, obviously, the first thing to check is V8’s ToBoolean mechanism. Which looks like this:
// ToString
//
// Convert the accumulator to a String.
IGNITION_HANDLER(ToBoolean, InterpreterAssembler) {
TNode
Next, we need to look at converting from booleans. As Yayu observes:
For select, we observed that the !!returnLeft conversion reaches V8’s Builtins_ToBoolean. The true and false cases execute instructions at different addresses within the builtin.
We separately used hardware read watchpoints to measure the data addresses accessed while V8 converts the boolean condition. This confirmed direct reads from the raw true and false Oddball objects in V8’s read-only heap:
condition
object base
to_number field
containing 64-byte line
true
0x...0c8
0x...0cc
0x...0c0
false
0x...0ac
0x...0b0
0x...080
The conversion executes loads of the following form, with rdi pointing to the condition’s Oddball object:
movl rdx, [rdi - 0x1] // load the Oddball's map
vmovsd xmm0, [rdi + 0x3] // load the Oddball's to_number field
Thus, the same load instruction accesses 0x...0cc for true and 0x...0b0 for false. The instruction address can be identical while its data operand reveals the condition through two different cache lines. This means that an executed-instruction trace alone can incorrectly classify the operation as constant-time; both instruction and data addresses must be considered.
This is observable from the source code, as the values for true and false are statically allocated.
This lines up close to what was reported in the disclosure, except 0xc9 is one off from the 0x...0c8 from the table, and 0xad is also one off from 0x...0ac.
I don’t actually know why there’s a discrepancy but it’s probably something harmless (like byte-alignment or a compiler optimization).
@cppObjectLayoutDefinition
@hasSameInstanceTypeAsParent
@doNotGenerateCast
extern class Boolean extends Oddball {}
@cppObjectLayoutDefinition
@hasSameInstanceTypeAsParent
@doNotGenerateCast
extern class True extends Boolean {}
@cppObjectLayoutDefinition
@hasSameInstanceTypeAsParent
@doNotGenerateCast
extern class False extends Boolean {}
This tells me that, internally, both true and false inherit from OddBall, so any of the branches that only trigger for OddBalls is relevant. This isn’t currently relevant, but is worth keeping in mind in the subsequent code snippets.
Altogether, this confirms the boolean type aspects of the report.
Observation: Avoiding booleans is the only way to be safe.
Next, we need to look at the double-negation (!!) behavior and how V8 handles signed zero, because -0 is a special value in IEEE 754 that JavaScript runtimes like V8 support, and how they support it could lead to timing leaks (as reported by Yayu).
Let’s also look at unary operators, with a focus on OddBalls, to tie into the earlier analysis.
TNode
The first highlight is a branch short-circuit that runs if the feedback isn’t undefined. The second highlight explains that this feedback mechanism can only be undefined on the first pass. This is the sort of engine optimization that makes side-channel-resistant code difficult.
Finally, we must look at unary negation (affects the (-var) & 0xff pattern used in constant-time programming):
BIND(&if_min_smi) calls SmiToFloat64 and jumps to do_float_op. This, altogether, is not guaranteed to take the same amount of time as simply returning a constant.
Without having to compile any code or figure out how to instrument any JIT behaviors, we can be sure that this code is designed to have side-channels.
This confirms the entirety of Yayu’s report. Now that we know where the problems lie, let’s figure out how to fix them.
Do not use the boolean type at all. That includes double-negation (!!var) or equality operators (===, !==).
Do not negate-and-mask, due to how -0 (signed zero) is handled in V8.
For example, the final step of my is_nonzero function looked like this:
/**
* Is this number anything except zero?
*
* @param {Uint8Array} num
* @returns {boolean}
*/
export function is_nonzero(num: Uint8Array): boolean {
let d: number = 0;
for (let i: number = num.length - 1; i >= 0; i--) {
d |= num[i];
}
return d !== 0;
}
To avoid the boolean type, we can use addition and bit-shifts. However, this changes the contract for is_nonzero(), since it now returns a number. To minimize compatibility woes, we can write an internal function (called is_nonzero_flag() since it returns a bit flag as a number rather than a boolean value) and keep the existing boolean is_nonzero(), which now just calls the new function and compares its value to 1.
@@ -95,11 +95,25 @@ export function gcd(a: Uint8Array, b: Uint8Array): Uint8Array {
* @returns {boolean}
*/
export function is_nonzero(num: Uint8Array): boolean {
+ return is_nonzero_flag(num) === 1;
+}
+
+/**
+ * Return 1 if this number is nonzero, or 0 otherwise.
+ *
+ * This numeric form is used as input to the selection functions so that a
+ * secret-derived boolean is never passed through V8's ToBoolean machinery.
+ *
+ * @param {Uint8Array} num
+ * @returns {number}
+ */
+function is_nonzero_flag(num: Uint8Array): number {
let d: number = 0;
for (let i: number = num.length - 1; i >= 0; i--) {
d |= num[i];
}
- return d !== 0;
+ // d is in [0, 255], so this maps zero to 0 and every other value to 1.
+ return (d + 0xff) >>> 8;
}
The existing outer API still has the boolean issues, but the places is_nonzero() is used in our library was more problematic because it was called in loops over potentially secret information. See also, the implementation for pow(), whose patch looks like so:
The same approach will be used to make select() constant-time.
Replace boolean with number, to avoid the boolean pitfalls
Change the mask generation strategy to not use !!
Since we’re no longer dealing with booleans, !!x can be (x & 1)
Avoid signed zeroes in interim calculations
-x can be replaced with 0 - (x & 1); subtracting from zero is a distinct operation from negating
The changes to select.ts are pretty short:
diff --git a/lib/select.ts b/lib/select.ts
index df6966d..7a8d4c3 100644
--- a/lib/select.ts
+++ b/lib/select.ts
@@ -1,21 +1,24 @@
import { int32 } from './int32';
/**
- * If TRUE, return left; else, return right.
+ * If choice is 1, return left; if it is 0, return right.
*
- * @param {boolean} returnLeft
+ * @param {number} choice (0 or 1)
* @param {Uint8Array} left
* @param {Uint8Array} right
* @returns {Uint8Array}
*/
-export function select(returnLeft: boolean, left: Uint8Array, right: Uint8Array): Uint8Array {
+export function select(choice: number, left: Uint8Array, right: Uint8Array): Uint8Array {
if (left.length !== right.length) {
throw new Error('select() expects two Uint8Array objects of equal length');
}
/*
- If returnLeft, mask = 0xFF; else, mask = 0x00;
+ If choice is 1, mask = 0xFF; else, mask = 0x00.
+
+ Keep this as subtraction from positive zero. Unary negation produces -0
+ for a zero choice, which V8 represents differently from the Smi value -1.
*/
- const mask: number = (-!!returnLeft) & 0xff;
+ const mask: number = (0 - (choice & 1)) & 0xff;
const out: Uint8Array = new Uint8Array(left.length);
for (let i: number = 0; i < left.length; i++) {
out[i] = right[i] ^ ((left[i] ^ right[i]) & mask);
@@ -35,7 +38,8 @@ export function select_alt(choice: number, m: Uint8Array, n: Uint8Array): Uint8A
if (m.length !== n.length) {
throw new Error('Both Uint8Arrays must be the same length');
}
- const mask = (-choice) & 0xff;
+ // See select(): subtraction from positive zero avoids materializing -0.
+ const mask = (0 - (choice & 1)) & 0xff;
const out = new Uint8Array(m.length);
for (let i: number = 0; i < out.length; i++) {
out[i] = n[i] ^ ((m[i] ^ n[i]) & mask);
@@ -55,7 +59,8 @@ export function select_ints(returnLeft: number, left: number, right: number): nu
/*
If returnLeft, mask = 0xFFFFFFFF; else, mask = 0x00000000;
*/
- const mask: number = (-(returnLeft & 1)) & 0xfffffffff;
+ // See select(): subtraction from positive zero avoids materializing -0.
+ const mask: number = 0 - (returnLeft & 1);
return right ^ ((left ^ right) & mask);
}
At this point, I still wasn’t finished there were still some administrivia to address (tests, README updates), and I also had to fix the CI configuration. Those aren’t interesting, though. With the power of hand-waving our problems away, we move on.
Just because the patch remediated the specific patterns that were initially reported doesn’t mean that there aren’t other leaks present. Nor does it mean that my fixes were complete.
Indeed, the is_nonzero() and pow() leakage I used as the earliest example in the previous section was identified after I fixed select() and looked for other crimes against the type system. If I had only looked at the scope of the reported issues, I might have missed that one.
But, okay. Since booleans are a lot of the problem, just avoiding using boolean variables at all is simple enough to verify: Does this code only use numbers and unary operators in places I formerly used booleans? Yes.
The other interesting question to address is: Did we successfully avoid -0?
If you recall from above, the diffs all had this pattern:
- const mask: number = (-!!returnLeft) & 0xff;
+ const mask: number = (0 - (choice & 1)) & 0xff;
The corrected code will be interpreted as bitwise AND operations (which, if those aren’t constant-time, this whole effort is doomed) and a single subtraction from zero.
TNode BinaryOpAssembler::Generate_SubtractWithFeedback(
const LazyNode& context, TNode lhs, TNode rhs,
TNode slot_id, const LazyNode& maybe_feedback_vector,
UpdateFeedbackMode update_feedback_mode, bool rhs_known_smi) {
auto smiFunction = [=, this](TNode lhs, TNode rhs,
TVariable* var_type_feedback) {
Label end(this);
TVARIABLE(Number, var_result);
// If rhs is known to be an Smi (for SubSmi) we want to fast path Smi
// operation. For the normal Sub operation, we want to fast path both
// Smi and Number operations, so this path should not be marked as Deferred.
Label if_overflow(this,
rhs_known_smi ? Label::kDeferred : Label::kNonDeferred);
var_result = TrySmiSub(lhs, rhs, &if_overflow);
*var_type_feedback = SmiConstant(BinaryOperationFeedback::kSignedSmall);
Goto(&end);
BIND(&if_overflow);
{
*var_type_feedback = SmiConstant(BinaryOperationFeedback::kNumber);
TNode value = Float64Sub(SmiToFloat64(lhs), SmiToFloat64(rhs));
var_result = AllocateHeapNumberWithValue(value);
Goto(&end);
}
BIND(&end);
return var_result.value();
};
auto floatFunction = [=, this](TNode lhs, TNode rhs) {
return Float64Sub(lhs, rhs);
};
return Generate_BinaryOperationWithFeedback(
context, lhs, rhs, slot_id, maybe_feedback_vector, smiFunction,
floatFunction, Operation::kSubtract, update_feedback_mode, rhs_known_smi);
}
In the highlighted section, rhs_known_smi is typically false (since this is a computed value, not a bytecode immediate value). This means that the decision will be determined by TrySmiSub, with the following:
lhs will be 0
rhs will be the result of (choice & 1)
Since this doesn’t overflow (any number between INT32_MIN and INT32_MAX is not considered to have overflowed; the Smi tagging is implemented here), the if_overflow label is never jumped to.
The only things that can easily go wrong now are:
The compiler turns out to be evil and introduces an “optimization” that I don’t anticipate
The V8 developers turn out to be evil and modify how this logic works and break my assumptions in a future release
Other supply-chain-shaped shenanigans with package management
And, well, that’s not part of the threat model for this demo code, now is it?
When I referred to the compiler or V8 developers turning “evil” above, I meant this in a completely tongue-in-cheek way. I don’t think either party is literally malicious.
I thought this was obvious, but a Hacker News commentator took offense to that, so consider this my clarification.
Neither the V8 developer team nor the various C/C++ compiler projects give a single shit about my little demo code. Nor should they.
I’ll take “Clarifications I didn’t think needed to exist” for $300, Alex.
After I got the fix written, I generated a diff and included it in my email to Yayu, who did not observe the same leakage when they applied their methodology to the patched code.
What Would Higher Assurance Look Like?
In the previous sections, I described what efforts I took to verify the side-channel vulnerability was real, how I wrote the patch, and how I checked that the patch actually solves the problem.
Some people will read this and wonder, “Why are we even trying to do this in JavaScript?”
The only way we solve the “don’t roll your own crypto” problem is if we meet developers halfway. Give them high-quality tools that solve their problem that undergo expert scrutiny, and they will have no reason to roll their own crypto.
Many developers who find themselves needing cryptography tools are writing software in languages that security geeks and cryptographers do not willingly or readily use for their work.
To that end, I take it upon myself to at least make an effort to satisfy their unmet needs.
it’s something!
But a more interesting question to consider is, “Can we do even better?”
One tempting solution is to write all of our cryptography in Rust (or some other security nerd approved language), compile the algorithms into WebAssembly (or, if you’re only server-side, FFI it instead), and not try to make interpreted code isochronic.
Unfortunately, there is no real constant-time guarantee for WebAssembly. As of this writing, a proposal exists, but it hasn’t been updated in 4 years.
While we’re talking about it, there really isn’t (broadly speaking) any guarantee around systems programming languages (C, Rust, etc.), either.
If you’ve never attended either event, here’s a few essential things to remember:
You choose your own adventure. Everything is multi-track. You cannot possibly attend every event on the schedule. Choose a few must-see events, and don’t be mad at yourself if you still end up missing one.
The convention is irreducible to the schedule. For some people, the most memorable events won’t be found in a meetup or panel. The “hallway track” (informal meetups and encounters between friends or even kind strangers) can be incredibly rewarding.
Almost everyone is a volunteer. You aren’t at a theme park, you’re surrounded by people with shared interests.
Remember to respect consent and boundaries. For example: Don’t take photos of a fursuiter having a wardrobe malfunction. Wait until they’ve fixed it and they might even pose with you!
Also, most fursuits have very poor vision, so if you think a fursuiter is ignoring you, they probably didn’t see you.
I like to spend my conventions hanging out with friends and meeting cool people. I usually dedicate several hours to simply being in fursuit and wandering around.
Sometimes, folks recognize me as the author of this blog. Rarely, someone will look at me and yell the wrong species (“Kitty!”).
Interestingly enough, despite doing two cons back-to-back, I don’t actually have many photos of myself in my fursuit.
This shouldn’t be too surprising, if you remember that I write long-form technical content rather than attention-grabbing reels on TikTok or YouTube Shorts.
Hell, I can barely dance, and that was only due to the efforts of a kind tiger and his other friends.
With the furry fandom continuing to grow at a breakneck exponential rate, this means that the probability of any given furry knowing about me (or even caring to know) approaches zero at a rate proportional to the fandom’s growth. Personal irrelevance is inevitable for this blog.
Of course, that doesn’t mean that I spent all my time like this:
Context is in a BlueSky thread. But for completeness: I sat near the stage. Since they were going to have a drag show, I figured everyone else would do the same. They decided to do a buffet-style dining experience, with the food on the opposite end of the room. Everyone sat near the food instead. Thus, I ended up at an empty table for the first like 5 minutes.
Influencers and Other Blights
Every once in a while, some random media influencer with a 6+ digit follower count decides to make a video about “what really goes on” at furry conventions. I won’t link any examples, but it’s a recurring topic.
But then you find gems like this:
If you haven’t watched Bekah’s video yet, and might want to, stop reading until you do. What I say after the next photo will spoil one of the more emotionally impactful parts of her video.
Fursuiting at DEFCON 2026. Photographer is anonymous.
In their desperate search for scandalous footage, self-proclaimed influencers whose only purpose in life is to provide clickbait filler between advertisements sure do miss a lot about their actual thesis.
I was mildly astonished that Bekah actually showed the memorial wall for the members of our community that have died. She shows more authenticity in her work than I’ve come to expect from YouTubers.
I don’t think I could ever trust any of the Discount Logan Pauls running around on multimedia platforms spreading mockery and ridicule to actually give a shit about the furry fandom or its members. But if they did actually care–if they had a modicum of respect or empathy for the people they’re trying to make a spectacle out of–they would find so much more interesting drama beneath the surface.
I’m writing this with the trust that nobody that reads my blog will try to start problems or harass anyone.
However, to make this expectation a bit more difficult to violate, I’m not including any names.
A few years ago, a friend of mine died. I found out when his boyfriend posted about it on Twitter and made it all about himself rather than my friend. Later, I found out that his boyfriend held a “seance” over VRChat in order to decide whether to attend a furry convention days later.
And, look, we all grieve differently, but to say that finding out that way didn’t hurt and piss me off would be a fucking lie.
This whole fucking ordeal could have unfolded right in front of one of these YouTube chucklefucks and they would be oblivious. They’d either cut the footage entirely because it doesn’t serve the “furries are sex-crazed losers” narrative they were gunning for, or make up some bullshit about it all secretly being a cult. And then jump-cut to them disrupting the dance competition or some shit.
My friend’s death was, at least in part, the result of his younger years of excessive alcohol use. In many of our private conversations, he talked about the pain of losing his ex to said ex’s drunk driving. But most of our conversations were forward-looking.
After his late grandmother had died and he received an inheritance, he invested some of it into a career change and planned to use the rest of it to help other furries with their own careers and financial security. I had written Furward Momentum the year before, so we ended up talking about that sort of thing a lot.
Trying to pretend that the lives of millions of people can fit into the same mold and/or soundbite is the kind of hubris that only dysfunctional institutions can believe is normal.
A few years ago, Joaquin Baldwin shared this sketch while recalling a conversation with Roe Grayfox:
If your narrative about a community cannot encapsulate moments like this, you’re probably lying whether you realize it or not.
Much Abuzz About “Fleas”
While I was fursuiting at Megaplex, someone clipped a clothespin to my tail without my notice until I got back to my hotel room, hours later. It had the word “flea” written on it in permanent marker.
Reasonable people can have different opinions about this.
Unreasonable people will insist that, if you don’t want strangers secretly attaching foreign objects to your thousand-dollar wearable work of art as part of an activity that isn’t officially on the convention’s programming, then “don’t go to cons” (archive).
Unreasonable people will harass and generally be nasty to the person that created the “fleas”.
Ad-supported social media platforms are incentivized to amplify the unreasonable.
AJLovesDinos
If you talk to a person with even a modicum of sense, you’ll get a spectrum of answers, which can be bucketed roughly like:
Oh, yeah, it’s cute and funny and whimsical. “I got fleas at the furry con!” Haha, good show, furries! Keep it up!
I get the humor, but I’m not personally comfortable with people touching me without my knowledge and consent.
What if folks started clipping airtags to fursuiters without their permission? This could easily normalize stalker behavior.
Meh, at least nobody’s being sexually harassed or assaulted.
One friend described it like taping a “kick me” sign to someone: If you’re doing it to a friend, then good fun and humor are almost certainly involved. If you’re doing it to a stranger, and then someone else actually kicks them because of it? Yikes.
Like, the goddamn sky isn’t falling either way, but we should probably as a community decide how we want to handle this conduct. None of that conversation requires anyone be nasty to anyone else. Put down the fucking beware doc.
It’s a private event with a dress code. Not every venue has to accommodate every subculture — and “discrimination” doesn’t automatically mean someone’s rights were violated.
Renaissance festivals are a lot of fun, but (at least in Florida, where I live) they’re not really equipped for fursuiting. They don’t have anything like an air conditioned Headless Lounge nor adequate water available.
Trying to fursuit at an outdoor event without the infrastructure needed to make it safe for attendees is certainly a choice that only the most dedicated of nerds would consider.
But singling out furries instead of other period-inaccurate garb (e.g., Star Wars) is at least a little suspicious, since only the furry community is really noteworthy for being overwhelmingly LGBTQIA+.
But who knows? Maybe there’s a furry in Maryland that personally ruined it for everyone. Stranger things have happened.
Speaking of renaissances, we need to talk about AI.
While I was at DEFCON, I estimate about 10% of the people that I talked to were either currently unemployed or extremely anxious about their income being displaced by management’s investments in AI.
Generative AI has never been popular among furries. Anything that harms artists isn’t going to be popular in a community of artists and their patrons. Add in the misinformation angle, juxtaposed with the baseless litterbox hoax, and you’ve got a recipe for conflict.
I don’t want to accidentally help the jerks who want to harm my community, nor the people who directly benefit from hyping up and subsequently bursting a bubble.
Too many other people are talking about it, and I’m burned out on hearing about it all the damn time.
However, some of the anti-AI folks have taken their cause into a weird direction by engaging in what one friend described as “outright reality denial”. This observation has precipitated beyond just discussions about LLMs.
In reality (whether or not anyone finds it convenient), AI can do useful work. There isn’t really much space for opinions or beliefs; it’s a measurable, empirical observation about the world we live in today.
All of the other players in this space are legacy BigTech corporations whose brutal policy decisions have a body count that would make some PMCs envious if they weren’t directed at their own employees and/or customers.
Possibly the cruelest part about this whole shitshow is how much AI enthusiasm is driven by fooling oneself.
Here’s a fun exercise: Clone a random security startup’s “skill” repo off GitHub and measure how many lines of it are Markdown instructions or TOML config defining different characters for the machine to roleplay, and compare it with lines of actual code. How much of that Markdown is reminding Claude what a SQL injection vulnerability looks like, as if it wasn’t absorbed into its training data?
Ever since my employer mandated the use of AI last year, the key difference I’ve observed between successful projects (whether development or security scanning) is the commitment to engineering best practices.
Y’know, the boring shit? Eating your wheaties?
To put it a bit more blunt, if you’re required to use AI at work and want to get anything useful, you need at least two things:
There are so many more interesting ways to be critical of this hellscape than trying to pretend that the technology is little more sophisticated than your iPhone’s “next word prediction” feature.
The biggest problem with AI is people.
Nobody reasonable is mad at linear algebra or computer science. Gradient descent, neural networks, transformer models, reinforcement learning, etc. are socially neutral concepts, inherently.
The wealthy investor class that hopes AI will displace entire industries’ workforces suck.
The CEOs and middle managers that decimate their workforce while enjoying record-breaking profits suck.
The people who use AI to spread misinformation and propaganda on social media suck.
The botlickers (sic) eager to sacrifice their neighbors and the environment for more cloud compute suck.
The grifters who use AI “art” to create profiles to try to blend in to subcultures they have no real interest in suck.
But as much as I do begrudge the people who changed the material conditions of our industry over the past few years in pursuit of their self-interest for the various harms they’ve caused, I do not extend this contempt towards junior developers or anyone at risk of losing their income tomorrow.
Just as you have to put on your own oxygen mask before you help others, do what you have to in order to survive the changing climate.
If reasonably practical, I do encourage you to find some way to maintain your independence: a way to do the basic skills that are now being automated without relying on any cloud-based service. Otherwise, those skills will almost certainly atrophy over time. There’s no such thing as a free lunch, after all.
This has been another grab-bag blog post stitched out of smaller topics that didn’t quite make the cut for a dedicated, focused writing.
I do these from time to time. A few people have complained about topic whiplash, so I’ve tried to make the transitions a bit less jarring this time around.
I’m planning to contribute to the DEFCON Furs badge puzzle for 2027. I’ve also offered to contribute cryptographic puzzles to Megaplex since their theme next year is Curse of Anubis, which has a lot of potential.
One of these days, I’m going to submit a CRYPTO rump session for a Fresh Prince of Bel-Air parody song titled Fresh Prints of Bellare. This will either force me to attend CRYPTO in fursuit, or mildly annoy the cryptography community.
Recently came across this one: The Escapades of Ponchi Panda is a very very strange black & white comic from Cosmic Lion, written and illustrated by D.B. Supr. “Join Inquisitor Ponchi Panda as he navigates the Dreamscape to rid its many realms of Creatures who feed on human emotion known as Nightmares. The Escapades of Ponchi Panda is a tale where Dreams, Folklore, and Reality all collide into one epic saga.” Check out the sample pages over at the web site.
The sun was bright during August, but the heat and storms didn’t hide themselves, testing our endurance throughout the month. We powered through and made it to a new month— and the leaves are beginning their colorful changes as our reward! Welcome to September, everyfur!
A huge reminder that we have the Book Bundle coming up in October! FWG members can fill out their application in the form below and have their book part of an entire wonderful selection of furry works. Authors get a share of the proceeds! We split the proceeds between all the authors, with one extra share that the guild keeps.
We’ve created another quick and easy way to support members of our guild. On Bluesky, we now have a Starter Pack for FWG Members and FWG Associate Members! If you’re part of the FWG and would like to be part of the Starter Pack, then contact the President or the Vice President and we’ll get you on the pack. If it gets full, then we’ll just make another one for more members! Help your fellow furry friends out and check out their works!
If you want to support the FWG more, then we have a Paypal and Patreon for you to donate to! This helps with future endeavors for this awesome guild we run here! So, if you choose to donate, thank you tons! We appreciate you forever and always!
Taking breaks is never a bad thing, my fellow writers and authors. Those breaks are essential to refuel and refresh our creative outlets. Don’t feel bad if you ever need to step away from a WIP to focus on anything else within your life. Pressure creates diamonds, yes, but it also creates rubble. Make sure that you’re not putting too much pressure on yourself and keep your mind stress free!
-Flash Kitterson
Here are the open markets from your Guild Markets Manager:
* #ohmurr – ertoica fiction, essays, hookup stories, poetry, and book reviews, 2,000 – 6,000 word essays, 1 – 2 pages of poetry, 100 – 300 word hookup stories, fiction and essays pay $20, closes Sep 20 | https://ohmurrmag.carrd.co/#submissionguidelines * Their next window opens Sep 21 and closes Nov 20
* MAWS VS PAWS – any genre (including erotica) about maw and/or paw play, 2,000 – 6,000 words, pays 0.5 cents/word | https://bewere.net/anthology.php
* Bewere – comics, graphic novels, artbooks, fiction, games, nonfiction, and other items, 32 – 100 page comics, 30,000 – 120,000 word fiction and nonfiction | https://bewere.net/submissions.php
* Fenris Publishing – comics, graphic novels, artbooks, fiction, games, nonfiction, and other items, 32 – 100 page comics, 30,000 – 120,000 word fiction and nonfiction | https://www.fenrispublishing.com/submissions.php
* Transcendent Fiction Publishing – [only accepting submission from trans men and women, nonbinary, and cis female authors] sci fi, fantasy, and furry comics, graphic novels, artbooks, novels, novellas, and single-author collections, 30,000 – 120,000 word novels, novellas, and collections | https://www.tfpublishing.com.au/submission-guidelines
* The Neurodiversiverse – Science fiction about neurodiverse people meeting aliens, <15,000 word stories and <200 line poems, pays $50 for flash, $100 for shots, and $50 for poetry, Closes Oct 1 | https://www.thinkinginkpress.com/ndv-submissions/
* Eye to the Telescope – Science fiction, fantasy, and speculative horror poetry about faeries, unknown length requirements, pays 7 cents/word, closes Oct 15 | https://eyetothetelescope.com/submit.html
* smoke and mold – Any genre for stories from non-human points of view, < 7,000 words (if poetry, only up to 2) but also comics, visual works, and “hybrid” work, pays $100, closes Sep 30 | https://smokeandmold.net/submissions/
* #EnbyLife – [Nonbinary and gender diverse authors only] Any genre and form on “tribute” theme, up to 100 words, pays $30 AUD, closes Sep 7 | https://enbylife.net/submissions/