Suppose you want to know what block or entity corresponds to a pixel on the screen. This can be done with pixel raycast.

All of this is client side.

There are two types, center pixel (crosshair) and arbitrary pixel.

This can be done with:

MinecraftClient client = MinecraftClient.getInstance();
HitResult hit = client.crosshairTarget;
 
switch(hit.getType()) {
    case Type.MISS:
        //nothing near enough
        break; 
    case Type.BLOCK:
        BlockHitResult blockHit = (BlockHitResult) hit;
        BlockPos blockPos = blockHit.getBlockPos();
        BlockState blockState = client.world.getBlockState(blockPos);
	Block block = blockState.getBlock();
        break; 
    case Type.ENTITY:
        EntityHitResult entityHit = (EntityHitResult) hit;
        Entity entity = entityHit.getEntity();
        break; 
}

For this one we need to precalculate a few things:

MinecraftClient client = MinecraftClient.getInstance();
int width = client.getWindow().getScaledWidth();
int height = client.getWindow().getScaledHeight();
Vec3d cameraDirection = client.cameraEntity.getRotationVec(tickDelta);
double fov = client.options.fov;
double angleSize = fov/height;
Vector3f verticalRotationAxis = new Vector3f(cameraDirection);
verticalRotationAxis.cross(Vector3f.POSITIVE_Y);
if(!verticalRotationAxis.normalize()) {
    return;//The camera is pointing directly up or down, you'll have to fix this one
}
 
Vector3f horizontalRotationAxis = new Vector3f(cameraDirection);
horizontalRotationAxis.cross(verticalRotationAxis);
horizontalRotationAxis.normalize();
 
verticalRotationAxis = new Vector3f(cameraDirection);
verticalRotationAxis.cross(horizontalRotationAxis);

Once you have that, you can use this function to calculate the direction vector that corresponds to the pixel:

private static Vec3d map(float anglePerPixel, Vec3d center, Vector3f horizontalRotationAxis,
    Vector3f verticalRotationAxis, int x, int y, int width, int height) {
    float horizontalRotation = (x - width/2f) * anglePerPixel;
    float verticalRotation = (y - height/2f) * anglePerPixel;
 
    final Vector3f temp2 = new Vector3f(center);
    temp2.rotate(verticalRotationAxis.getDegreesQuaternion(verticalRotation));
    temp2.rotate(horizontalRotationAxis.getDegreesQuaternion(horizontalRotation));
    return new Vec3d(temp2);
}

Then you have this reimplementation of the code at GameRenderer#updateTargetedEntity:

private static HitResult rayTraceInDirection(MinecraftClient client, float tickDelta, Vec3d direction) {
    Entity entity = client.getCameraEntity();
    if (entity == null || client.world == null) {
        return null;
    }
 
    double reachDistance = client.interactionManager.getReachDistance();
    HitResult target = rayTrace(entity, reachDistance, tickDelta, false, direction);
    boolean tooFar = false;
    double extendedReach = reachDistance;
    if (client.interactionManager.hasExtendedReach()) {
        extendedReach = 6.0D;
        reachDistance = extendedReach;
    } else {
        if (reachDistance > 3.0D) {
            tooFar = true;
        }
    }
 
    Vec3d cameraPos = entity.getCameraPosVec(tickDelta);
 
    extendedReach = extendedReach * extendedReach;
    if (target != null) {
        extendedReach = target.getPos().squaredDistanceTo(cameraPos);
    }
 
    Vec3d vec3d3 = cameraPos.add(direction.multiply(reachDistance));
    Box box = entity
            .getBoundingBox()
            .stretch(entity.getRotationVec(1.0F).multiply(reachDistance))
            .expand(1.0D, 1.0D, 1.0D);
    EntityHitResult entityHitResult = ProjectileUtil.rayTrace(
            entity,
            cameraPos,
            vec3d3,
            box,
            (entityx) -> !entityx.isSpectator() && entityx.collides(),
            extendedReach
    );
 
    if (entityHitResult == null) {
        return target;
    }
 
    Entity entity2 = entityHitResult.getEntity();
    Vec3d vec3d4 = entityHitResult.getPos();
    double g = cameraPos.squaredDistanceTo(vec3d4);
    if (tooFar && g > 9.0D) {
        return null;
    } else if (g < extendedReach || target == null) {
        target = entityHitResult;
        if (entity2 instanceof LivingEntity || entity2 instanceof ItemFrameEntity) {
            client.targetedEntity = entity2;
        }
    }
 
    return target;
}
 
private static HitResult rayTrace(
        Entity entity,
        double maxDistance,
        float tickDelta,
        boolean includeFluids,
        Vec3d direction
) {
    Vec3d end = entity.getCameraPosVec(tickDelta).add(direction.multiply(maxDistance));
    return entity.world.rayTrace(new RayTraceContext(
            entity.getCameraPosVec(tickDelta),
            end,
            RayTraceContext.ShapeType.OUTLINE,
            includeFluids ? RayTraceContext.FluidHandling.ANY : RayTraceContext.FluidHandling.NONE,
            entity
    ));
}

Once you have the direction and the raytracer, you can put them together:

Vec3d direction = map(
        (float) angleSize,
        cameraDirection,
        horizontalRotationAxis,
        verticalRotationAxis,
        x,
        y,
        width,
        height
);
HitResult hit = rayTraceInDirection(client, tickDelta, direction);
 
switch(hit.getType()) {
    case Type.MISS:
        //nothing near enough
        break; 
    case Type.BLOCK:
        BlockHitResult blockHit = (BlockHitResult) hit;
        BlockPos blockPos = blockHit.getBlockPos();
        BlockState blockState = client.world.getBlockState(blockPos);
	Block block = blockState.getBlock();
        break; 
    case Type.ENTITY:
        EntityHitResult entityHit = (EntityHitResult) hit;
        Entity entity = entityHit.getEntity();
        break; 
}

Here x and y are you pixel coordinates.

This is EXPENSIVE, if you do it too many times, it WILL get slow.