Here we'll cover creation of a custom fluid. If you plan to create several fluids, it is recommended to make an abstract basic fluid class where you'll set necessary defaults that will be shared in its subclasses. We'll also make it generate in the world like lakes.

Vanilla fluids extend net.minecraft.fluid.FlowableFluid, and so shall we.

public abstract class TutorialFluid extends FlowableFluid {
	/**
	 * @return whether the given fluid an instance of this fluid
	 */
	@Override
	public boolean matchesType(Fluid fluid) {
		return fluid == getStill() || fluid == getFlowing();
	}
 
	/**
	 * @return whether the fluid infinite like water
	 */
	@Override
	protected boolean isInfinite() {
		return false;
	}
 
	/**
	 * Perform actions when fluid flows into a replaceable block. Water drops
	 * the block's loot table. Lava plays the "block.lava.extinguish" sound.
	 */
	@Override
	protected void beforeBreakingBlock(WorldAccess world, BlockPos pos, BlockState state) {
		final BlockEntity blockEntity = state.hasBlockEntity() ? world.getBlockEntity(pos) : null;
		Block.dropStacks(state, world, pos, blockEntity);
	}
 
	/**
	 * Lava returns true if its FluidState is above a certain height and the
	 * Fluid is Water.
	 * 
	 * @return whether the given Fluid can flow into this FluidState
	 */
	@Override
	protected boolean canBeReplacedWith(FluidState fluidState, BlockView blockView, BlockPos blockPos, Fluid fluid, Direction direction) {
		return false;
	}
 
	/**
	 * Possibly related to the distance checks for flowing into nearby holes?
	 * Water returns 4. Lava returns 2 in the Overworld and 4 in the Nether.
	 */
	@Override
	protected int getFlowSpeed(WorldView worldView) {
		return 4;
	}
 
	/**
	 * Water returns 1. Lava returns 2 in the Overworld and 1 in the Nether.
	 */
	@Override
	protected int getLevelDecreasePerBlock(WorldView worldView) {
		return 1;
	}
 
	/**
	 * Water returns 5. Lava returns 30 in the Overworld and 10 in the Nether.
	 */
	@Override
	public int getTickRate(WorldView worldView) {
		return 5;
	}
 
	/**
	 * Water and Lava both return 100.0F.
	 */
	@Override
	protected float getBlastResistance() {
		return 100.0F;
	}
}

Now let's make an actual fluid which will have still and flowing variants. For this tutorial, we will call it Acid. The missing references will be filled in shortly.

public abstract class AcidFluid extends TutorialFluid {
	@Override
	public Fluid getStill() {
		return YOUR_STILL_FLUID_HERE;
	}
 
	@Override
	public Fluid getFlowing() {
		return YOUR_FLOWING_FLUID_HERE;
	}
 
	@Override
	public Item getBucketItem() {
		return YOUR_BUCKET_ITEM_HERE;
	}
 
	@Override
	protected BlockState toBlockState(FluidState fluidState) {
		return YOUR_FLUID_BLOCK_HERE.getDefaultState().with(Properties.LEVEL_15, getBlockStateLevel(fluidState));
	}
 
	public static class Flowing extends AcidFluid {
		@Override
		protected void appendProperties(StateManager.Builder<Fluid, FluidState> builder) {
			super.appendProperties(builder);
			builder.add(LEVEL);
		}
 
		@Override
		public int getLevel(FluidState fluidState) {
			return fluidState.get(LEVEL);
		}
 
		@Override
		public boolean isStill(FluidState fluidState) {
			return false;
		}
	}
 
	public static class Still extends AcidFluid {
		@Override
		public int getLevel(FluidState fluidState) {
			return 8;
		}
 
		@Override
		public boolean isStill(FluidState fluidState) {
			return true;
		}
	}
}

Next, we'll make static instances of still and flowing acid variants, and an acid bucket. In your ModInitializer:

public static FlowableFluid STILL_ACID;
public static FlowableFluid FLOWING_ACID;
public static Item ACID_BUCKET;
 
@Override
public void onInitialize() {
	STILL_ACID = Registry.register(Registry.field_11154, new Identifier(MOD_ID, "acid"), new AcidFluid.Still());
	FLOWING_ACID = Registry.register(Registry.field_11154, new Identifier(MOD_ID, "flowing_acid"), new AcidFluid.Flowing());
	ACID_BUCKET = Registry.register(Registry.field_11142, new Identifier(MOD_ID, "acid_bucket"), 
        new BucketItem(STILL_ACID, new Item.Settings().recipeRemainder(Items.BUCKET).maxCount(1)));
 
	// ...
}
 
// ...

To make a custom fluid behave more like water or lava, you must add it to a corresponding fluid tag: For water, make a data/minecraft/tags/fluids/water.json file and write the identifiers of your fluids in there:

{
	"replace": false,
	"values":
	[
		"your_mod_id:acid",
		"your_mod_id:flowing_acid"
	]
}

Next we need to create a block which will represent acid in the world. net.minecraft.block.FluidBlock is the class we need to use, but since its constructor is protected, we can't construct it directly. Some ways to use it are to make a subclass or an anonymous subclass. Here we will be showing the latter. In your ModInitializer:

public static Block ACID;
 
@Override
public void onInitialize() {
	ACID = Registry.register(Registry.field_11146, new Identifier(MOD_ID, "acid"), new FluidBlock(STILL_ACID, FabricBlockSettings.copy(Blocks.WATER)){});
 
	// ...
} 

Now that we have these static objects, we can go back to AcidFluid and fill in the overridden methods:

public abstract class AcidFluid extends TutorialFluid {
	@Override
	public Fluid getStill() {
		return TutorialMod.STILL_ACID;
	}
 
	@Override
	public Fluid getFlowing() {
		return TutorialMod.FLOWING_ACID;
	}
 
	@Override
	public Item getBucketItem() {
		return TutorialMod.ACID_BUCKET;
	}
 
	@Override
	protected BlockState toBlockState(FluidState fluidState) {
		// getBlockStateLevel converts the LEVEL_1_8 of the fluid state to the LEVEL_15 the fluid block uses
		return TutorialMod.ACID.getDefaultState().with(Properties.LEVEL_15, getBlockStateLevel(fluidState));
	}
 
	public static class Flowing extends AcidFluid {
		@Override
		protected void appendProperties(StateManager.Builder<Fluid, FluidState> builder) {
			super.appendProperties(builder);
			builder.add(LEVEL);
		}
 
		@Override
		public int getLevel(FluidState fluidState) {
			return fluidState.get(LEVEL);
		}
 
		@Override
		public boolean isStill(FluidState fluidState) {
			return false;
		}
	}
 
	public static class Still extends AcidFluid {
		@Override
		public int getLevel(FluidState fluidState) {
			return 8;
		}
 
		@Override
		public boolean isStill(FluidState fluidState) {
			return true;
		}
	}
}  

For your fluids to have textures or be tinted with a color, you will need to register a FluidRenderHandler for them. Here, we will reuse water's textures and just change the tint color applied to them. To make sure the textures are rendered as translucent, you can use Fabric's BlockRenderLayerMap.

public class TutorialModClient implements ClientModInitializer {
 
	@Override
	public void onInitializeClient() {
		setupFluidRendering(TutorialMod.STILL_ACID, TutorialMod.FLOWING_ACID, new Identifier("minecraft", "water"), 0x4CC248);
		BlockRenderLayerMap.INSTANCE.putFluids(RenderLayer.getTranslucent(), TutorialMod.STILL_ACID, TutorialMod.FLOWING_ACID);
 
		// ...
	}
 
	public static void setupFluidRendering(final Fluid still, final Fluid flowing, final Identifier textureFluidId, final int color) {
		final Identifier stillSpriteId = new Identifier(textureFluidId.getNamespace(), "block/" + textureFluidId.getPath() + "_still");
		final Identifier flowingSpriteId = new Identifier(textureFluidId.getNamespace(), "block/" + textureFluidId.getPath() + "_flow");
 
		// If they're not already present, add the sprites to the block atlas
		ClientSpriteRegistryCallback.event(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE).register((atlasTexture, registry) -> {
			registry.register(stillSpriteId);
			registry.register(flowingSpriteId);
		});
 
		final Identifier fluidId = Registry.field_11154.getId(still);
		final Identifier listenerId = new Identifier(fluidId.getNamespace(), fluidId.getPath() + "_reload_listener");
 
		final Sprite[] fluidSprites = { null, null };
 
		ResourceManagerHelper.get(ResourceType.CLIENT_RESOURCES).registerReloadListener(new SimpleSynchronousResourceReloadListener() {
			@Override
			public Identifier getFabricId() {
				return listenerId;
			}
 
			/**
			 * Get the sprites from the block atlas when resources are reloaded
			 */
			@Override
			public void reload(ResourceManager resourceManager) {
				final Function<Identifier, Sprite> atlas = MinecraftClient.getInstance().getSpriteAtlas(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE);
				fluidSprites[0] = atlas.apply(stillSpriteId);
				fluidSprites[1] = atlas.apply(flowingSpriteId);
			}
		});
 
		// The FluidRenderer gets the sprites and color from a FluidRenderHandler during rendering
		final FluidRenderHandler renderHandler = new FluidRenderHandler()
		{
			@Override
			public Sprite[] getFluidSprites(BlockRenderView view, BlockPos pos, FluidState state) {
				return fluidSprites;
			}
 
			@Override
			public int getFluidColor(BlockRenderView view, BlockPos pos, FluidState state) {
				return color;
			}
		};
 
		FluidRenderHandlerRegistry.INSTANCE.register(still, renderHandler);
		FluidRenderHandlerRegistry.INSTANCE.register(flowing, renderHandler);
	}
}

If you want to use your own fluid textures, you can refer to vanilla's assets ¹⁾ as a template.

To make lakes of acid generate in the world, you can create a net.minecraft.world.gen.feature.LakeFeature in your ModInitializer and then add it to the biomes you want it to generate in:

public static LakeFeature ACID_LAKE;
 
@Override
public void onInitialize() {
	ACID_LAKE = Registry.register(Registry.FEATURE, new Identifier(MOD_ID, "acid_lake"), new LakeFeature(SingleStateFeatureConfig::deserialize));
 
	// generate in swamps, similar to water lakes, but with a chance of 40 (the higher the number, the lower the generation chance)
	Biomes.SWAMP.addFeature(
		GenerationStep.Feature.LOCAL_MODIFICATIONS,
		ACID_LAKE.configure(new SingleStateFeatureConfig(ACID.getDefaultState()))
			.createDecoratedFeature(Decorator.WATER_LAKE.configure(new ChanceDecoratorConfig(40)))
	);
}

You may be noticed that your custom fluid is too much similar to water. In this section we'll cover some customizations, like adding custom fog and fog color, “strenght” (pushing back the player), and adding custom sounds and particles.

Unfortunately, for now, there isn't a way to do this normally, and even with Fabric Api, so we need to use mixins to change the behaviour of Entity class and and BackgroundRenderer class.

To start, remove the fluid from the water tag we added previously, and add a custom tag for custom behaviours:

//Add in the main mod file
public static final Tag<Fluid> FABRIC_FLUIDS = TagFactory.FLUID.create(new Identifier(MOD_ID, "fabric_fluid"));

Then set all fluids that you want to customize to your custom tag:

/data/tutorial/tags/fabric_fluid.json

{
  "replace": false,
  "values":
  [
    "tutorial:acid",
    "tutorial:flowing_acid"
  ]
}

To make things simpler and more customizable, let's add an interface to get the fog values:

public interface FabricFlowableFluid {
    /**
     * Get the fog color.
     */
    int getFogColor(Entity focusedEntity);
 
    /**
     * Get the fog start value.
     */
    float getFogStart(Entity focusedEntity);
 
    /**
     * Get the fog end value.
     */
    float getFogEnd(Entity focusedEntity);
}

Now you must implement this interface to the previous example fluid class:

public abstract class AcidFluid extends TutorialFluid implements FabricFlowableFluid {
 
    [...]
 
    /**
     * Get the fog color.
     */
    @Override
    public int getFogColor(Entity focusedEntity) {
        //Set the fog color to #99ff33 for a light green acid.
        return 0x99ff33;
    }
 
    /**
     * Get the fog start value. (Lava uses 0.25f, and 0.0f if the player has fire resistance)
     */
    @Override
    public float getFogStart(Entity focusedEntity) {
        //You can use focusedEntity to get the effects, just comment for now.
        //if (entity instanceof LivingEntity && ((LivingEntity)entity).hasStatusEffect(StatusEffects.FIRE_RESISTANCE)) return 0.0f;
        return 0.25f;
    }
 
    /**
     * Get the fog end value. (Lava uses 1.0f, and 3.0f if the player has fire resistance)
     */
    @Override
    public float getFogEnd(Entity focusedEntity) {
        //You can use focusedEntity to get the effects, just comment for now.
        //if (entity instanceof LivingEntity && ((LivingEntity)entity).hasStatusEffect(StatusEffects.FIRE_RESISTANCE)) return 3.0f
        return 1.0f;
    }
 
    [...]
}

To make the game use these values we must use an inject mixin to two methods inside the BackgroundRenderer class:

• render : This will render the fog color
• applyFog : This will aplly the fog with the start and end parameters.

@Mixin(BackgroundRenderer.class)
public class BackgroundRendererMixin {
    @Shadow private static float red;
    @Shadow private static float green;
    @Shadow private static float blue;
    @Shadow private static long lastWaterFogColorUpdateTime = -1L;
 
    @Inject(method = "render(Lnet/minecraft/client/render/Camera;FLnet/minecraft/client/world/ClientWorld;IF)V",
            at = @At("HEAD"),
            cancellable = true)
    private static void render(Camera camera, float tickDelta, ClientWorld world, int i, float f, CallbackInfo ci) {
 
        //Get the fluid that submerged the camera
        FluidState fluidState = ((FabricCamera)camera).getSubmergedFluidState();
 
        //If this is an instance of FabricFlowableFluid interface...
        if (fluidState.getFluid() instanceof FabricFlowableFluid fluid) {
 
            //Get the color of the fog...
            int fogColor = fluid.getFogColor(camera.getFocusedEntity());
 
            //This is an hexadecimal color, so we need to get the three "red", "green", and "blue" values.
            red = (fogColor >> 16 & 255) / 255f;
            green = (fogColor >> 8 & 255) / 255f;
            blue = (fogColor & 255) / 255f;
 
            //This is for compatibility, just add!
            lastWaterFogColorUpdateTime = -1L;
 
            //Apply the color, then return.
            RenderSystem.clearColor(red, green, blue, 0.0f);
 
            ci.cancel();
        }
    }
 
    @Inject(method = "applyFog(Lnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/BackgroundRenderer$FogType;FZ)V",
            at = @At("HEAD"),
            cancellable = true)
    private static void applyFog(Camera camera, BackgroundRenderer.FogType fogType, float viewDistance, boolean thickFog, CallbackInfo ci) {
 
        //Get the fluid that submerged the camera
        FluidState fluidState = ((FabricCamera)camera).getSubmergedFluidState();
 
        //If this is an instance of FabricFlowableFluid interface...
        if (fluidState.getFluid() instanceof FabricFlowableFluid fluid) {
 
            //Get the start and end parameters and apply them, then return.
            RenderSystem.setShaderFogStart(fluid.getFogStart(camera.getFocusedEntity()));
            RenderSystem.setShaderFogEnd(fluid.getFogEnd(camera.getFocusedEntity()));
 
            ci.cancel();
        }
    }
}

From 1.17 camera has not the getSubmergedFluidState method so, as you can see, we must “re-add” it, this is pretty simple.

Add a FabricCamera interface:

public interface FabricCamera {
    /**
     * Returns the fluid in which the camera is submerged.
     */
    FluidState getSubmergedFluidState();
}

Add a mixin to get the value (Accessor) from the camera:

@Mixin(Camera.class)
public class CameraMixin implements FabricCamera {
    @Shadow private BlockView area;
    @Shadow @Final private BlockPos.Mutable blockPos;
 
    /**
     * Returns the fluid in which the camera is submerged.
     */
    @Override
    public FluidState getSubmergedFluidState() {
        return this.area.getFluidState(this.blockPos);
    }
}

For first, extend the previous FabricFlowableFluid interface to get the values and make custom behaviours.

Now it will be like this:

public interface FabricFlowableFluid {
    /**
     * Get the fog color.
     */
    int getFogColor(Entity focusedEntity);
 
    /**
     * Get the fog start value.
     */
    float getFogStart(Entity focusedEntity);
 
    /**
     * Get the fog end value.
     */
    float getFogEnd(Entity focusedEntity);
 
    /**
     * Get the fluid pushing strength.
     */
    double getStrength();
 
    /**
     * Get the fluid splash sound.
     */
    Optional<SoundEvent> getSplashSound();
 
    /**
     * Make things when the player splashes on the fluid (like jumping).
     */
    void onSplash(World world, Vec3d pos, Entity entity);
}

Add the new methods implementations to the fluid class:

public abstract class AcidFluid extends TutorialFluid implements FabricFlowableFluid {
 
    [...]
 
    /**
     * Get the fluid pushing strength. (Water uses 0.014d, Lava uses 0.0023333333333333335d, and 0.007d in the Nether)
     */
    @Override
    double getStrength() {
        return 0.014d;
    }
 
    /**
     * Get the fluid splash sound.
     */
    @Override
    Optional<SoundEvent> getSplashSound() {
        //For this example we will use the strider step sound in lava.
        return Optional.of(SoundEvents.ENTITY_STRIDER_STEP_LAVA);
    }
 
    /**
     * Make things when the player splashes on the fluid (like jumping).
     */
    @Override
    void onSplash(World world, Vec3d pos, Entity entity) {
        //You can use the parameters in this method to add the particles you want.
        //This is an example that will show a smoke particle when hitting the fluid (or jumping on it).
        //pos is the position of each block of still state, or flowing state, of the fluid, it represents the corner of the block.
        //entity is the entity that caused the splash event.
        world.addParticle(ParticleTypes.SMOKE, pos.getX(), h + 1.0F, pos.getZ(), 0.02d, 0.02d, 0.02d);
    }
 
    [...]
}

Now we must add a mixin to checkWaterState method of Entity class to make the fluid use our custom behaviours.

For now we will disable the swimming on the fluid, this will be covered in the future.

@Mixin(Entity.class)
public abstract class EntityMixin {
    @Shadow public World world;
    @Shadow private BlockPos blockPos;
    @Shadow protected boolean firstUpdate;
    @Shadow public float fallDistance;
    @Shadow protected boolean touchingWater;
    protected boolean touchingFabricFlowableFluid;
 
    @Shadow @Nullable public abstract Entity getVehicle();
    @Shadow public abstract boolean updateMovementInFluid(Tag<Fluid> tag, double d);
    @Shadow public abstract void extinguish();
    //@Shadow protected abstract void onSwimmingStart();
    @Shadow public abstract void setSwimming(boolean swimming);
    @Shadow public abstract boolean isRegionUnloaded();
    @Shadow public abstract void playSound(SoundEvent sound, float volume, float pitch);
    @Shadow public abstract double getX();
    @Shadow public abstract double getY();
    @Shadow public abstract double getZ();
 
 
    @Inject(method = "checkWaterState()V",
            at = @At("HEAD"),
            cancellable = true)
    void checkWaterState(CallbackInfo ci) {
        if (this.getVehicle() instanceof BoatEntity) {
 
            //If the player is on a boat it doesn't touch the fluid
            this.touchingWater = false; //This is added for compatibility with water.
            this.touchingFabricFlowableFluid = false;
 
            ci.cancel();
        } else {
 
            //Gets the fluid strength
            double fluidStrength = getFluidStrength();
 
            //Triggers the movement in the fluid
            if (fluidStrength != -1 && this.updateMovementInFluid(FabricFluidTags.FABRIC_FLUIDS, fluidStrength)) {
                if (!this.touchingFabricFlowableFluid && !this.firstUpdate) {
                    //If the player has jumped on the fluid, or touched the fluid for the first fime, executes the touched method below
                    this.onFabricFlowableFluidTouched();
                    //this.onSwimmingStart();
                }
 
                //This prevents fall damage when hitting the fluid (like water).
                this.fallDistance = 0.0F;
 
                //When the player is on the fluid set touching to true.
                this.touchingFabricFlowableFluid = true;
                this.touchingWater = true; //This is added for compatibility with water.
 
                //This extinguish the fire from the player (like water).
                this.extinguish();
 
                ci.cancel();
            }
            else {
                //When the player leaved the fluid (or jumped from it) set touching to false.
                this.touchingFabricFlowableFluid = false;
            }
        }
    }
 
    /**
     * This is not very important, will simply disable swimming on the fluid for now.
     */
    @Inject(method = "updateSwimming()V",
            at = @At("HEAD"),
            cancellable = true)
    public void updateSwimming(CallbackInfo ci) {
        if (this.touchingFabricFlowableFluid) {
            //Disable swimming
            setSwimming(false);
 
            ci.cancel();
        }
    }
 
    /**
     * Get the fluid pushing strength from the fluid.
     */
    private double getFluidStrength() {
        if (this.isRegionUnloaded()) {
            return -1;
        } else {
            FluidState fluidState = this.world.getFluidState(this.blockPos);
            if (fluidState.getFluid() instanceof FabricFlowableFluid fluid) {
                return fluid.getStrength();
            }
            else return -1;
        }
    }
 
    /**
     * Executed when the player touches the fluid for the first time, or jumps on it.
     */
    private void onFabricFlowableFluidTouched() {
        FluidState fluidState = this.world.getFluidState(this.blockPos);
        if (fluidState.getFluid() instanceof FabricFlowableFluid fluid) {
 
            //Gets and play the splash sound
            fluid.getSplashSound().ifPresent(soundEvent -> this.playSound(soundEvent, 1f, 1f));
 
            //Execute the onSplash event
            fluid.onSplash(this.world, new Vec3d(this.getX(), this.getY(), this.getZ()), (Entity)(Object)this);
        }
    }
}