a rect drawn with stroke(255) pretty much looks the same as the lines:

It sounds like line() is the right tool to draw lines, and not using one pixel wide rectangles, but it just doesn't look good.

At the same time, rect() is slower than line(). 

Why aren't lines more precise? Can it be fixed?

all i'm saying there are reasons why the inner part of a rect looks differently than a line. for instance, really how thick is this rect with it's corners one 1px apart but without rendering it's borders?  as i stated above, as soon as you use borders on the rect it starts to look like the line. 

so, i don't agree that a line should look the same as a 1px wide rect with noStroke(). a line should look the same as a 1px wide rect *with* stroke(), and it does.

This example:

You can see how the decimals are being ignored. The three lines look identical.

When drawing rectangles without noStroke() this rounding (or flooring, to be more precise) is not happening, and that's why it looks great.

Maybe it's happening on purpose, to make it faster. But it would be great to be able to choose if we want this rounding or not.

2. void setup() {
3.   size(400, 400);
4.   smooth();
5. }
6. void draw() {
7.   background(255);
8.   
9.   float x = cos(frameCount / 1000.0) * 100;
10.   float y = sin(frameCount / 1000.0) * 100;
11.   
12.   translate(200, 200);
13.   
14.   // draw a normal red line
15.   stroke(200, 0, 0);
16.   line(0, 0, x, y);
17. 
    
18.   // draw a smooth blue line
19.   fill(0, 0, 200);
20.   sline(0, 0, y, x);  
21. }
22. 
    
23. void sline(float x0, float y0, float x1, float y1) {
24.   noStroke();
25.   pushMatrix();
26.   translate(x0, y0);
27.   rotate(atan2(y1-y0, x1-x0));
28.   rect(0, 0, dist(x0, y0, x1, y1), 1);
29.   popMatrix();
30. }

I haven't tested it in other programs, but I guess one could replace line() by sline() if this kind of antialiasing is needed.

i agree it would be nice to have fractional endpoints, but this depends on some sort of anti-aliasing / smoothing, so do you think smooth() should take care of that?

~

with the opengl renderer, the lines don't look the same, so fractional endpoints seem to have an effect in this case. the antialiasing looks horrible though!

When it works there is no antialias anyway. My integrated Intel card is not so great I guess.

2. void sline(float x0, float y0, float x1, float y1) {
3.   noStroke();
4.   pushMatrix();
5.   translate(x0+0.5, y0+0.5);
6.   rotate(atan2(y1-y0, x1-x0));
7.   rect(-0.5, -0.5, dist(x0, y0, x1, y1)+1, 1);
8.   popMatrix();
9. }

According to this test program the lengths and positions seem to be right: