Category: Blog

  • Furry Studies third academic conference planned for Australia, call for proposals

    Furry Studies third academic conference planned for Australia, call for proposals

    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.

    More information can be found at https://furrystudies.org/ and https://bsky.app/profile/furrystudies.org!

    Furry Studies also has a Telegram announcement channel: https://t.me/furrystudiesconf

    – Zeldstarro

    Like the article? These take hard work. For more free furry news, follow on Bluesky or support not-for-profit Dogpatch Press on Patreon. Want to get involved? Try these subreddits: r/furrydiscuss for news or r/waginheaven for the best of the community. Or send guest writing here. (Content Policy.)

    Original post written by Dogpatch Press Staff

  • Toronto’s Summer of Fur (2026) – Guest post by Arrkay

    Toronto’s Summer of Fur (2026) – Guest post by Arrkay

    Welcome to Arrkay, a Toronto furry who produces Furry Film Burrow, a Youtube channel dedicated to furry community projects. See Arrkay’s tag for previous stories.

    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.

    (more…)

  • The “Mayhem Guy’s” Wooden Performance…

    The “Mayhem Guy’s” Wooden Performance…

    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…

    (I’d pull up a chair to watch this match!)

    Original post written by vulpesffb

  • No, He’s Not Puff

    No, He’s Not Puff

    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.

    image c. 2026 Abrams Books

    Original post written by rodney

  • The V8 JavaScript Runtime Undermined My Constant-Time JavaScript Library

    The V8 JavaScript Runtime Undermined My Constant-Time JavaScript Library

    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).

    Soatok Yay Sticker
    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.

    While at a furry convention last month, I received an email from a Ph.D student named Yayu Wang which disclosed a side-channel in constant-time-js. I have since released version 0.5.0 of the library, which fixes the issue reported, and used GitHub’s security advisories feature to request a CVE.

    The full credits are as follows:

    Vulnerability discovered and reported by Yayu Wang. Research done by Yayu Wang, Kjell Dankert, Duy Kha Dinh, and Aastha Mehta, University of British Columbia.

    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?

    Art: CMYKat

    Contents

    Timeline

    • 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 value = GetAccumulator();
      TVARIABLE(Boolean, result);
      Label if_true(this), if_false(this), end(this);
      BranchIfToBooleanIsTrue(value, &if_true, &if_false);
      BIND(&if_true);
      {
        result = TrueConstant();
        Goto(&end);
      }
      BIND(&if_false);
      {
        result = FalseConstant();
        Goto(&end);
      }
      BIND(&end);
      SetAccumulator(result.value());
      Dispatch();
    }
    
    
    

    Oh, hey, BranchIfToBooleanIsTrue(). That name sure sounds like a branching side-channel would be exposed. And, indeed, that is what we observe.

    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.

      static constexpr Tagged_t kUndefinedValue = 0x69;
      static constexpr Tagged_t kNullValue = 0x85;
      static constexpr Tagged_t kempty_string = 0xa1;
      static constexpr Tagged_t kFalseValue = 0xad;
      static constexpr Tagged_t kTrueValue = 0xc9;
    

    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.

    Soatok thinking sticker
    I don’t actually know why there’s a discrepancy but it’s probably something harmless (like byte-alignment or a compiler optimization).

    Art: CMYKat

    We can further inspect the OddBall object…

    @cppObjectLayoutDefinition
    @apiExposedInstanceTypeValue(0x83)
    @highestInstanceTypeWithinParentClassRange
    extern class Oddball extends PrimitiveHeapObject {
      to_number_raw: float64;
      to_string: String;
      to_number: Number;
      type_of: String;
      kind: Smi;
    }
    

    …and the True/False subclass definitions.

    @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).

    Observe from the AccessBuilder class that HeapNumber::value_ and OddBall::to_number_raw_ are equivalent.

    // static
    FieldAccess AccessBuilder::ForHeapNumberOrOddballOrHoleValue() {
      STATIC_ASSERT_FIELD_OFFSETS_EQUAL(offsetof(HeapNumber, value_),
                                        offsetof(Oddball, to_number_raw_));
      STATIC_ASSERT_FIELD_OFFSETS_EQUAL(offsetof(HeapNumber, value_),
                                        Hole::kRawNumericValueOffset);
      return ForHeapNumberValue();
    }
    

    Let’s also look at unary operators, with a focus on OddBalls, to tie into the earlier analysis.

      TNode UnaryOpWithFeedback(TNode context, TNode value,
                                        TNode slot,
                                        TNode maybe_feedback_vector,
                                        const SmiOperation& smi_op,
                                        const FloatOperation& float_op,
                                        const BigIntOperation& bigint_op,
                                        UpdateFeedbackMode update_feedback_mode) {
        TVARIABLE(Object, var_value, value);
        TVARIABLE(Object, var_result);
        TVARIABLE(Float64T, var_float_value);
        TVARIABLE(Smi, var_feedback, SmiConstant(BinaryOperationFeedback::kNone));
        TVARIABLE(Object, var_exception);
        Label start(this, {&var_value, &var_feedback}), end(this);
        Label do_float_op(this, &var_float_value);
        Label if_exception(this, Label::kDeferred);
        Goto(&start);
        // We might have to try again after ToNumeric conversion.
        BIND(&start);
        {
          Label if_smi(this), if_heapnumber(this), if_oddball(this);
          Label if_bigint(this, Label::kDeferred);
          Label if_other(this, Label::kDeferred);
          value = var_value.value();
          GotoIf(TaggedIsSmi(value), &if_smi);
    
          TNode value_heap_object = CAST(value);
          TNode map = LoadMap(value_heap_object);
          GotoIf(IsHeapNumberMap(map), &if_heapnumber);
          TNode instance_type = LoadMapInstanceType(map);
          GotoIf(IsBigIntInstanceType(instance_type), &if_bigint);
          Branch(InstanceTypeEqual(instance_type, ODDBALL_TYPE), &if_oddball,
                 &if_other);
    
          BIND(&if_smi);
          {
            var_result =
                smi_op(CAST(value), &var_feedback, &do_float_op, &var_float_value);
            Goto(&end);
          }
    
          BIND(&if_heapnumber);
          {
            var_float_value = LoadHeapNumberValue(value_heap_object);
            Goto(&do_float_op);
          }
    
          BIND(&if_bigint);
          {
            var_result = bigint_op(context, value_heap_object);
            CombineFeedback(&var_feedback, BinaryOperationFeedback::kBigInt);
            Goto(&end);
          }
    
          BIND(&if_oddball);
          {
            // We do not require an Or with earlier feedback here because once we
            // convert the value to a number, we cannot reach this path. We can
            // only reach this path on the first pass when the feedback is kNone.
            CSA_DCHECK(this, SmiEqual(var_feedback.value(),
                                      SmiConstant(BinaryOperationFeedback::kNone)));
            OverwriteFeedback(&var_feedback,
                              BinaryOperationFeedback::kNumberOrOddball);
            var_value = LoadOddballToNumber(CAST(value_heap_object));
            Goto(&start);
          }
    
          BIND(&if_other);
          {
            // We do not require an Or with earlier feedback here because once we
            // convert the value to a number, we cannot reach this path. We can
            // only reach this path on the first pass when the feedback is kNone.
            CSA_DCHECK(this, SmiEqual(var_feedback.value(),
                                      SmiConstant(BinaryOperationFeedback::kNone)));
            OverwriteFeedback(&var_feedback, BinaryOperationFeedback::kAny);
            {
              ScopedExceptionHandler handler(this, &if_exception, &var_exception);
              var_value = CallBuiltin(Builtin::kNonNumberToNumeric, context,
                                      value_heap_object);
            }
            Goto(&start);
          }
        }
    
        BIND(&if_exception);
        {
          UpdateFeedback(var_feedback.value(), maybe_feedback_vector, slot,
                         update_feedback_mode);
          CallRuntime(Runtime::kReThrow, context, var_exception.value());
          Unreachable();
        }
    
        BIND(&do_float_op);
        {
          CombineFeedback(&var_feedback, BinaryOperationFeedback::kNumber);
          var_result =
              AllocateHeapNumberWithValue(float_op(var_float_value.value()));
          Goto(&end);
        }
    
        BIND(&end);
        UpdateFeedback(var_feedback.value(), maybe_feedback_vector, slot,
                       update_feedback_mode);
        return var_result.value();
      }
    
    
    

    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):

      TNode Negate(TNode context, TNode value,
                           TNode slot,
                           TNode maybe_feedback_vector,
                           UpdateFeedbackMode update_feedback_mode) {
        SmiOperation smi_op =
            [=, this](TNode smi_value, TVariable* var_feedback,
                      Label* do_float_op, TVariable* var_float) {
              TVARIABLE(Number, var_result);
              Label if_zero(this), if_min_smi(this), end(this);
              // Return -0 if operand is 0.
              GotoIf(SmiEqual(smi_value, SmiConstant(0)), &if_zero);
    
              // Special-case the minimum Smi to avoid overflow.
              GotoIf(SmiEqual(smi_value, SmiConstant(Smi::kMinValue)), &if_min_smi);
    
              // Else simply subtract operand from 0.
              CombineFeedback(var_feedback, BinaryOperationFeedback::kSignedSmall);
              var_result = SmiSub(SmiConstant(0), smi_value);
              Goto(&end);
    
              BIND(&if_zero);
              CombineFeedback(var_feedback, BinaryOperationFeedback::kNumber);
              var_result = MinusZeroConstant();
              Goto(&end);
    
              BIND(&if_min_smi);
              *var_float = SmiToFloat64(smi_value);
              Goto(do_float_op);
    
              BIND(&end);
              return var_result.value();
            };
        FloatOperation float_op = [=, this](TNode float_value) {
          return Float64Neg(float_value);
        };
        BigIntOperation bigint_op = [=, this](TNode context,
                                              TNode bigint_value) {
          return CAST(CallRuntime(Runtime::kBigIntUnaryOp, context, bigint_value,
                                  SmiConstant(Operation::kNegate)));
        };
        return UnaryOpWithFeedback(context, value, slot, maybe_feedback_vector,
                                   smi_op, float_op, bigint_op,
                                   update_feedback_mode);
      }
    
    
    

    BIND(&if_zero) returns a constant.

    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.

    Writing The Patch

    To arrive at the patch for the reported issues, I set the following goals for myself:

    1. Do not use the boolean type at all. That includes double-negation (!!var) or equality operators (===, !==).
    2. 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:

    @@ -315,7 +329,7 @@ export function pow(a: Uint8Array, n: Uint8Array): Uint8Array {
             rshift1(e, true);
             Sprime = multiply(S, S);
             S = select(
    -            is_nonzero(e),
    +            is_nonzero_flag(e),
                 Sprime,
                 normalize(S, Sprime.length)
             );
    

    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.

    Verifying The Fix

    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.

    So we just need to see how subtraction is handled by V8:

    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.

    poorly drawn star with the words
    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.

    However, there is ongoing work to make that happen.

    Closing Thoughts

    I hope this was an interesting enough dive into the side-channel vulnerability I accidentally introduced in my demo code.

    The header art was made by AJ_LovesDinos.

    Original post written by Soatok

  • Multi-Track Fursuiting?!

    Multi-Track Fursuiting?!

    Last month, I attended both DEFCON and Megaplex. If you’re not familiar with either event, here’s all you need to know.

    DEFCON is a hacker convention with a substantial furry presence.

    Megaplex is a furry convention with a substantial hacker presence.

    Photo taken with Chevron Wolf at Megaplex 2026. Furtrack.

    If you’ve never attended either event, here’s a few essential things to remember:

    1. 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.
    2. 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.
    3. Almost everyone is a volunteer. You aren’t at a theme park, you’re surrounded by people with shared interests.
    4. 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!
      1. 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.

    Soatok's blue dhole fursuit
    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.

    Not all furry discourse is the usual suspects.

    Art: CMYKat

    Two Certainties: Death and Foxes

    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:

    Joaquin Baldwin, originally shared on Twitter

    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.

    Soatok yelling at his computer
    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.

    The Renaissance Of Furry Aversion

    Recently, the Maryland Renaissance Festival decided to ban fursuits. If you’re suppressing a yawn at that headline, take a look at how this was announced on social media (archive):

    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.

    Hmm. What did they mean by this?

    Soatok thinking sticker
    Will anyone crack this puzzle?
    CMYKat

    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.

    You Can’t Spell FAIL Without AI

    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.

    In the past, I’ve neglected to cover AI on this blog (aside from complaining about the lack of consent in companies’ decisionmaking), for a few distinct reasons:

    1. 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.
    2. 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.

    As I write this, OpenAI is claiming a solution to the Navier-Stokes Millennium Prize Problem. This has led to statements from other mathematicians. Terrence Tao weighed in too. Even if this turns out to be a correct solution, it doesn’t change the fact that it’s also a marketing stunt.

    The main competitor to OpenAI is a company called Anthropic, whose CEO writes MST3K-worthy essays with titles like Machines of Loving Grace that feel like “What if Jim Jones read LessWrong?” and whose wife (and key strategic advisor) contacted Jeffrey Epstein years after his conviction to pitch a “luxury porn” startup.

    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?

    Then, is it any wonder that the Internet is nigh-unusable due to the prevalence of AI bots that scrape webpages over and over instead of just cloning a repo locally?

    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:

    1. A good definition of “done”
    2. A tight feedback loop

    AI enthusiasts could probably point an LLM at my Public Key Directory specification and get a working client in virtually any programming language due to the assurance practices I’ve been strictly adhering to. Of course, their coding agent will get all the credit if they do.

    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.

    Closing Remarks

    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.


    Header photo was taken by yosh at Megaplex 2026.

    Original post written by Soatok

  • Panda Punches Pestilence

    Panda Punches Pestilence

    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.

    image c. 2026 Cosmic Lion Productions

    Original post written by rodney

  • FR Radio DJ Show Every Friday at 5pm EST

    Attention all music-loving furs! 🎧🎉 Join us tonight at 5pm EST for Furry Refuge Radio’s DJ Show! 🐾🎶

    📅 Date: EVERY FRIDAY

    ⏰ Time: 5:00 PM EST

    🎵 DJ: Queen Angel

    🎉 Location: OUR RADIO CHATROOM https://t.me/+JnMFyCm0_K1lMjdh
    AND
    RADIO STATION: https://radio.furryrefuge.com

    PLEASE SPREAD THE WORD!

    #FurryRefugeRadio #FurryRadio #FurryBeats #FurryDJ #FurryMusic

    ​

  • FWG Newsletter September 2026

    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.

    Find the Book Bundle form here! https://forms.gle/nMVXyyzWGhtCTg347

    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!

    Find the Starter Pack here! https://bsky.app/starter-pack/furrywritersguild.bsky.social/3mrqiuhsbsn2m

    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!

    FWG Paypal: https://www.paypal.com/donate/?hosted_button_id=2ACUCFGMBZY4A

    FWG Patreon: patreon.com/furrywritersguild

    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:

    September open markets:

    ## Open now!

    ### Short fiction, nonfiction, and poetry:

    * Children of the Night – any genre (including erotica) about the goth subculture, 5,000 – 20,000 words, pays 0.5 cents/word, closes Dec 31 | https://armouredfoxpress.wixsite.com/website/furry-call-for-submissions

    * This is Halloween – any genre (including erotica) about Halloween, 3,000 – 12,000 words, pays 0.5 cents/word, closes Dec 31 | https://armouredfoxpress.wixsite.com/website/furry-call-for-submissions

    * The Voice of Dog – any genre, < 10,000 words | https://thevoice.dog/?page=rules

    * Dinner at Yiffany’s – erotica, <15,000 words | https://www.dinneratyiffanys.com/story-submission-guidelines/

    * Rho Iota Phi – horror and erotica in a college frat shared universe, 3,000 – 12,000 words, pays 0.5 cents/word, closes Oct 31 | https://armouredfoxpress.wixsite.com/website/furry-call-for-submissions

    * #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


    ### Books:

    * FurPlanet – comics and magazines, unknown wordcount minimums/maximums | https://furplanet.com/shop/custom.aspx?recid=8

    * 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

    * Doppelfoxx Publishing – comics, graphic novels, artbooks, poetry chapbooks, poetry collections, novels, and novellas, unknown wordcount minimums/maximums | https://doppelfoxxpublishing.com/pages/publication

    ### Non-furry Publishers, but furry-interest calls:

    * Untitled Orc Erotica Anthology
    – Orc erotica,  5,000 – 20,000 words, pays 0.5 cents/word, unknown close date | https://armouredfoxpress.wixsite.com/website/nf-call-for-submissions

    * 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

    * Of Fae & Fire – Romantasy with fae, 2,000 – 4,000-ish words (but you can go a little otuside that), pays 8 cents/word, closes Sep 13 | https://blog.flametreepublishing.com/fantasy-gothic/romantic-fantasy-call-for-submissions

    * 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/

    * Superheroes, Super Problems – Superheroes and/or villains, <5,000 words, pays 8 cents/word, closes Oct 15 | https://wordfirewestern.moksha.io/publication/superheroes-super-problems/guidelines

    Please check out the latest book releases from our members:
    Tethers Torn [Book 2], by Utunu, Released March 2026.
    Archon [Book 2], by Mark Smith, Released March 27th, 2026.
    Disaster Queers: Night at the Museum, by Alison Cybe, Released April 1st, 2026.
    Howling Dead, by Vincenzo Pasquarella, Released April 13th, 2026.
    Space Dragons: Cosmic Survivors, by Veo Corva, Released April 20, 2026
    Travels, by Erin Lee, Released April 26th.
    A Rodent of Unusual Size, by Rebecca Cascane, Released April 26th.
    The Morning After, by J.F.R. Coates, Released April 26th.
    Weasel Under the Sun (A Stone & Cooke Mystery), by Kyell Gold, Released May 2026.
    Game Of Life, by Rob MacWolf & Alex Vance, Released June 15th, 2026.
    Lesser Gods: Retribution, by Alex Frey, Released June 16th, 2026.
    Disaster Queers: Emmlie’s Eleven, by Alison Cybe, Released July 25th, 2026.
    Helkite, by Roscoe G. Beetle, Released August 26th, 2026.
    UPCOMING!!
    The Moonhound, by K.C. Shaw, Releases October 2026.

    FWG Members- remember to use the Promotion Tip Line!
    https://forms.gle/keTnEt1UG59qMqZ29

    Original post written by F.K.